system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-05 18:01:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/libtest/vartest.c
Pavel Roskin 734247b529 Casts to (SEGPTR) removed. They did nothing anyway. 
Includes added or removed where necessary.
Win16 functions replaced with their Win32 counterparts. Comments added
where it was impossible.
CALLBACK added where necessary. Some declarations fixed.
Constructs like "#if WINDOWS" corrected. Using "#ifdef __unix__" instead.
DlgProc in hello3 uses EndDialog() instead of DestroyWindow().
Listbox enabled in hello3.
1999-04-03 13:52:04 +00:00

1045 lines
39 KiB
C
Raw Blame History

/*
* VARIANT test program
*
* Copyright 1998 Jean-Claude Cote
*
* The purpose of this program is validate the implementation
* of the APIs related to VARIANTs. The validation is done
* by comparing the results given by the Windows implementation
* versus the Wine implementation.
*
* This program tests the creation/coercion/destruction of VARIANTs.
*
* The program does not currently test any API that takes
* arguments of type: IDispatch, IUnknown, DECIMAL, CURRENCY.
*
* Since the purpose of this program is to compare the results
* from Windows and Wine it is written so that with a simple
* define it can be compiled either in Windows or Linux.
*
*
* NOTES
* - The Variant structure in Windows has a non-named union. This means
* the member of the union are accessible simply by doing pVariant->pfltVal.
* With gcc it is not possible to have non-named union so it has been named
* 'u'. So it's members are accessible using this name like so
* pVariant->u.pfltVal. So if this program is compiled in Windows
* the references to 'u' will need to be take out of this file.
*
* - Also the printf is a little different so the format specifiers may
* need to be tweaked if this file is compile in Windows.
* Printf is also different in that it continues printing numbers
* even after there is no more significative digits left to print. These
* number are garbage and in windows they are set to zero but not
* on Linux.
*
* - The VarDateFromStr is not implemented yet.
*
* - The date and floating point format may not be the exact same format has the one in
* windows depending on what the Internatinal setting are in windows.
*
*/
#include <stdio.h>
#include <malloc.h>
#include <windows.h>
#include <winerror.h>
#include <winnt.h>
#include <oleauto.h>
#include <math.h>
#include <float.h>
#include <time.h>
#include <windef.h>
#ifdef __unix__
#include <debugstr.h>
extern LPWSTR HEAP_strdupAtoW( HANDLE heap, DWORD flags, LPCSTR str );
#endif
static const int MAX_BUFFER = 1024;
#ifndef __unix__
char* WtoA( OLECHAR* p )
{
int i = 0;
char* pc = (char *)malloc( MAX_BUFFER*sizeof(char) );
pc[0] = '\"';
pc++;
i = wcstombs( pc, p, MAX_BUFFER );
if( i < MAX_BUFFER-1 )
{
pc[i] = '\"';
pc[i+1] = '\0';
}
pc--;
return pc;
}
OLECHAR* AtoW( char* p )
{
int i = 0;
OLECHAR* pwc = (OLECHAR *)malloc( MAX_BUFFER*sizeof(OLECHAR) );
i = mbstowcs( pwc, p, MAX_BUFFER );
return pwc;
}
#else
char* WtoA( OLECHAR* p )
{
return debugstr_wn( p, MAX_BUFFER );
}
OLECHAR* AtoW( char* p )
{
return HEAP_strdupAtoW( GetProcessHeap(), 0, p );
}
#endif
int PASCAL WinMain (HANDLE inst, HANDLE prev, LPSTR cmdline, int show)
{
VARIANTARG va;
VARIANTARG vb;
VARIANTARG vc;
VARIANTARG vd;
VARIANTARG ve;
int theInt = 0;
int* pInt = &theInt;
VARIANT_BOOL b = 0;
VARIANT_BOOL* pBool = &b;
unsigned short uShort = 0;
unsigned short* pUShort = &uShort;
unsigned long uLong = 0;
unsigned long* pULong = &uLong;
CHAR theChar;
CHAR* pChar = &theChar;
BYTE byte;
BYTE* pByte = &byte;
short s = 0;
short* pShort = &s;
long Long = 0;
long* pLong = &Long;
float f = 0;
float* pFloat = &f;
double d = 0;
double* pDouble = &d;
unsigned short i = 0;
HRESULT res = 0;
BSTR bstr = NULL;
int olePtrIndex = 0;
int nOlePtrs = 120;
OLECHAR* pOleChar[120];
pOleChar[0] = AtoW( "-2" );
pOleChar[1] = AtoW( "-1" );
pOleChar[2] = AtoW( "-0.51" );
pOleChar[3] = AtoW( "-0.5" );
pOleChar[4] = AtoW( "-0.49" );
pOleChar[5] = AtoW( "-0.0" );
pOleChar[6] = AtoW( "0.0" );
pOleChar[7] = AtoW( "0.49" );
pOleChar[8] = AtoW( "0.5" );
pOleChar[9] = AtoW( "0.51" );
pOleChar[10] = AtoW( "1" );
pOleChar[11] = AtoW( "127" );
pOleChar[12] = AtoW( "128" );
pOleChar[13] = AtoW( "129" );
pOleChar[14] = AtoW( "255" );
pOleChar[15] = AtoW( "256" );
pOleChar[16] = AtoW( "257" );
pOleChar[17] = AtoW( "32767" );
pOleChar[18] = AtoW( "32768" );
pOleChar[19] = AtoW( "-32768" );
pOleChar[20] = AtoW( "-32769" );
pOleChar[21] = AtoW( "16777216" );
pOleChar[22] = AtoW( "16777217" );
pOleChar[23] = AtoW( "-16777216" );
pOleChar[24] = AtoW( "16777217" );
pOleChar[25] = AtoW( "2147483647" );
pOleChar[26] = AtoW( "2147483648" );
pOleChar[27] = AtoW( "-2147483647" );
pOleChar[28] = AtoW( "-2147483648" );
pOleChar[29] = AtoW( "" );
pOleChar[30] = AtoW( " " );
pOleChar[31] = AtoW( "1F" );
pOleChar[32] = AtoW( "1G" );
pOleChar[33] = AtoW( " 1 " );
pOleChar[34] = AtoW( " 1 2 " );
pOleChar[35] = AtoW( "1,2,3" );
pOleChar[36] = AtoW( "1 2 3" );
pOleChar[37] = AtoW( "1,2, 3" );
pOleChar[38] = AtoW( "1;2;3" );
pOleChar[39] = AtoW( "1.2.3" );
pOleChar[40] = AtoW( "0." );
pOleChar[41] = AtoW( ".0" );
pOleChar[42] = AtoW( "0.1E12" );
pOleChar[43] = AtoW( "2.4,E1" );
pOleChar[44] = AtoW( " +3.2,E1" );
pOleChar[45] = AtoW( "4E2.5" );
pOleChar[46] = AtoW( " 2E+2" );
pOleChar[47] = AtoW( "1 E+2" );
pOleChar[48] = AtoW( "." );
pOleChar[49] = AtoW( ".E2" );
pOleChar[50] = AtoW( "1000000000000000000000000000000000000000000000000000000000000000" );
pOleChar[51] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
pOleChar[52] = AtoW( "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
pOleChar[53] = AtoW( "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
pOleChar[54] = AtoW( "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001" );
pOleChar[55] = AtoW( "65535" );
pOleChar[56] = AtoW( "65535.5" );
pOleChar[57] = AtoW( "65536" );
pOleChar[58] = AtoW( "4294967295" );
pOleChar[59] = AtoW( "4294967296" );
pOleChar[60] = AtoW( "1 January 99" );
pOleChar[61] = AtoW( "December 31, 2078" );
pOleChar[62] = AtoW( "January 1, 1900" );
pOleChar[63] = AtoW( "January 2 1900" );
pOleChar[64] = AtoW( "11.11.1999" );
pOleChar[65] = AtoW( "11/11/1999" );
pOleChar[66] = AtoW( " 11 / 11 / 1999" );
pOleChar[67] = AtoW( "11/11/1999:11:11:1134" );
pOleChar[68] = AtoW( "11/11/1999 11:11:11:1" );
pOleChar[69] = AtoW( "\t1999/\t11/21 11 :11:11am" );
pOleChar[70] = AtoW( "11/11/1999 11:11:11Am" );
pOleChar[71] = AtoW( "11/11/1999 11:11:11PM" );
pOleChar[72] = AtoW( "11/11/199911:11:11PM" );
pOleChar[73] = AtoW( "11/11/1999 0:0:11am" );
pOleChar[74] = AtoW( "11/11/1999 11,11:11am" );
pOleChar[75] = AtoW( "11/11/1999 11:11:11am" );
pOleChar[76] = AtoW( "11/11/1999 11/11:11am" );
pOleChar[77] = AtoW( "11/11/1999 11:11AM" );
pOleChar[78] = AtoW( "11/11/1999 1AM" );
pOleChar[79] = AtoW( "11/11/1999 0AM" );
pOleChar[80] = AtoW( "11/11/1999 11:11:11" );
pOleChar[81] = AtoW( "11/13/1999 0AM" );
pOleChar[82] = AtoW( "13/13/1999 0AM" );
pOleChar[83] = AtoW( "13/11/1999 0AM" );
pOleChar[84] = AtoW( "11/33/1999 0AM" );
pOleChar[85] = AtoW( "11/11/1999 AM" );
pOleChar[86] = AtoW( "1/1/0 0AM" );
pOleChar[87] = AtoW( "1/1/-1 0AM" );
pOleChar[88] = AtoW( "1999 January 3 9AM" );
pOleChar[89] = AtoW( "1 January 1999 11AM" );
pOleChar[90] = AtoW( "4AM 11/11/1999" );
pOleChar[91] = AtoW( "4:22 11/11/1999 AM" );
pOleChar[92] = AtoW( " 1 1 /11/1999" );
pOleChar[93] = AtoW( "11-11/1999 11:11:11.12AM" );
pOleChar[94] = AtoW( "1999 January 3, 9AM" );
pOleChar[95] = AtoW( "December, 31, 2078" );
pOleChar[96] = AtoW( "December, 31, 2078," );
pOleChar[97] = AtoW( "December, 31 2078" );
pOleChar[98] = AtoW( "11/99" );
pOleChar[99] = AtoW( "11-1999" );
pOleChar[100] = AtoW( "true" );
pOleChar[101] = AtoW( "True" );
pOleChar[102] = AtoW( "TRue" );
pOleChar[103] = AtoW( "TRUE" );
pOleChar[104] = AtoW( " TRUE" );
pOleChar[105] = AtoW( "FALSE " );
pOleChar[106] = AtoW( "False" );
pOleChar[107] = AtoW( "JustSomeText" );
pOleChar[108] = AtoW( "Just Some Text" );
pOleChar[109] = AtoW( "" );
pOleChar[110] = AtoW( "1.5" );
pOleChar[111] = AtoW( "2.5" );
pOleChar[112] = AtoW( "3.5" );
pOleChar[113] = AtoW( "4.5" );
pOleChar[114] = AtoW( "" );
pOleChar[115] = AtoW( "" );
pOleChar[116] = AtoW( "" );
pOleChar[117] = AtoW( "" );
pOleChar[118] = AtoW( "" );
pOleChar[119] = AtoW( "" );
/* Start testing the Low-Level API ( the coercions )
*/
/* unsigned char from...
*/
printf( "\n\n======== Testing VarUI1FromXXX ========\n");
/* res = VarUI1FromI2( 0, NULL );
*/
printf( "VarUI1FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
res = VarUI1FromStr( NULL, 0, 0, pByte );
printf( "VarUI1FromStr: passing in NULL as param: %X\n", (unsigned int) res );
res = VarUI1FromI2( 0, pByte );
printf( "VarUI1FromI2: 0, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 69, pByte );
printf( "VarUI1FromI2: 69, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 70, pByte );
printf( "VarUI1FromI2: 70, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 128, pByte );
printf( "VarUI1FromI2: 128, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 255, pByte );
printf( "VarUI1FromI2: 255, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 256, pByte );
printf( "VarUI1FromI2: 256, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromI2( 257, pByte );
printf( "VarUI1FromI2: 257, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 0.0, pByte );
printf( "VarUI1FromR8: 0.0, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 69.33, pByte );
printf( "VarUI1FromR8: 69.33, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 69.66, pByte );
printf( "VarUI1FromR8: 69.66, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( -69.33, pByte );
printf( "VarUI1FromR8: -69.33, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( -69.66, pByte );
printf( "VarUI1FromR8: -69.66, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( -0.5, pByte );
printf( "VarUI1FromR8: -0.5, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( -0.51, pByte );
printf( "VarUI1FromR8: -0.51, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( -0.49, pByte );
printf( "VarUI1FromR8: -0.49, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 0.5, pByte );
printf( "VarUI1FromR8: 0.5, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 0.51, pByte );
printf( "VarUI1FromR8: 0.51, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromR8( 0.49, pByte );
printf( "VarUI1FromR8: 0.49, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromDate( 0.0, pByte );
printf( "VarUI1FromDate: 0.0, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromDate( 69.33, pByte );
printf( "VarUI1FromDate: 69.33, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromDate( 69.66, pByte );
printf( "VarUI1FromDate: 69.66, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromDate( -69.33, pByte );
printf( "VarUI1FromDate: -69.33, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromDate( -69.66, pByte );
printf( "VarUI1FromDate: -69.66, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromBool( VARIANT_TRUE, pByte );
printf( "VarUI1FromBool: VARIANT_TRUE, %X, %X\n", *pByte, (unsigned int) res );
res = VarUI1FromBool( VARIANT_FALSE, pByte );
printf( "VarUI1FromBool: VARIANT_FALSE, %X, %X\n", *pByte, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarUI1FromStr( pOleChar[olePtrIndex], 0, 0, pByte );
printf( "VarUI1FromStr: %s, %X, %X\n", WtoA(pOleChar[olePtrIndex]), *pByte, (unsigned int) res );
}
/* unsigned short from ...
*/
printf( "\n\n======== Testing VarUI2FromXXX ========\n");
res = VarUI2FromI2( -1, &i );
printf( "VarUI2FromI2: -1, %d, %X\n", i, (unsigned int) res );
/* res = VarUI2FromI2( 0, NULL );
*/
printf( "VarUI2FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
res = VarUI2FromStr( NULL, 0, 0, pUShort );
printf( "VarUI2FromStr: passing in NULL as param: %X\n", (unsigned int) res );
res = VarUI2FromI2( 0, pUShort );
printf( "VarUI2FromI2: 0, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI2( 69, pUShort );
printf( "VarUI2FromI2: 69, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI2( 70, pUShort );
printf( "VarUI2FromI2: 70, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI2( 128, pUShort );
printf( "VarUI2FromI2: 128, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI4( 65535, pUShort );
printf( "VarUI2FromI4: 65535, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI4( 65536, pUShort );
printf( "VarUI2FromI4: 65536, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromI4( 65537, pUShort );
printf( "VarUI2FromI4: 65537, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 0.0, pUShort );
printf( "VarUI2FromR8: 0.0, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 69.33, pUShort );
printf( "VarUI2FromR8: 69.33, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 69.66, pUShort );
printf( "VarUI2FromR8: 69.66, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( -69.33, pUShort );
printf( "VarUI2FromR8: -69.33, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( -69.66, pUShort );
printf( "VarUI2FromR8: -69.66, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( -0.5, pUShort );
printf( "VarUI2FromR8: -0.5, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( -0.51, pUShort );
printf( "VarUI2FromR8: -0.51, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( -0.49, pUShort );
printf( "VarUI2FromR8: -0.49, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 0.5, pUShort );
printf( "VarUI2FromR8: 0.5, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 0.51, pUShort );
printf( "VarUI2FromR8: 0.51, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromR8( 0.49, pUShort );
printf( "VarUI2FromR8: 0.49, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromDate( 0.0, pUShort );
printf( "VarUI2FromDate: 0.0, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromDate( 69.33, pUShort );
printf( "VarUI2FromDate: 69.33, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromDate( 69.66, pUShort );
printf( "VarUI2FromDate: 69.66, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromDate( -69.33, pUShort );
printf( "VarUI2FromDate: -69.33, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromDate( -69.66, pUShort );
printf( "VarUI2FromDate: -69.66, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromBool( VARIANT_TRUE, pUShort );
printf( "VarUI2FromBool: VARIANT_TRUE, %u, %X\n", *pUShort, (unsigned int) res );
res = VarUI2FromBool( VARIANT_FALSE, pUShort );
printf( "VarUI2FromBool: VARIANT_FALSE, %u, %X\n", *pUShort, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarUI2FromStr( pOleChar[olePtrIndex], 0, 0, pUShort );
printf( "VarUI2FromStr: %s, %u, %X\n", WtoA(pOleChar[olePtrIndex]), (int)*pUShort, (unsigned int) res );
}
/* unsigned long from ...
*/
printf( "\n\n======== Testing VarUI4FromXXX ========\n");
/*res = VarUI4FromI2( 0, NULL );
*/
printf( "VarUI4FromI2: passing in NULL as return val makes it crash, %X\n", (unsigned int) res );
res = VarUI4FromStr( NULL, 0, 0, pULong );
printf( "VarUI4FromStr: passing in NULL as param: %X\n", (unsigned int) res );
res = VarUI4FromI2( 0, pULong );
printf( "VarUI4FromI2: 0, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromI2( 69, pULong );
printf( "VarUI4FromI2: 69, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromI2( 70, pULong );
printf( "VarUI4FromI2: 70, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromI2( 128, pULong );
printf( "VarUI4FromI2: 128, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromI2( 255, pULong );
printf( "VarUI4FromI2: 255, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 4294967295.0, pULong );
printf( "VarUI4FromR8: 4294967295, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 4294967296.0, pULong );
printf( "VarUI4FromR8: 4294967296, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 0.0, pULong );
printf( "VarUI4FromR8: 0.0, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 69.33, pULong );
printf( "VarUI4FromR8: 69.33, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 69.66, pULong );
printf( "VarUI4FromR8: 69.66, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( -69.33, pULong );
printf( "VarUI4FromR8: -69.33, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( -69.66, pULong );
printf( "VarUI4FromR8: -69.66, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( -0.5, pULong );
printf( "VarUI4FromR8: -0.5, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( -0.51, pULong );
printf( "VarUI4FromR8: -0.51, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( -0.49, pULong );
printf( "VarUI4FromR8: -0.49, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 0.5, pULong );
printf( "VarUI4FromR8: 0.5, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 0.51, pULong );
printf( "VarUI4FromR8: 0.51, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromR8( 0.49, pULong );
printf( "VarUI4FromR8: 0.49, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromDate( 0.0, pULong );
printf( "VarUI4FromDate: 0.0, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromDate( 69.33, pULong );
printf( "VarUI4FromDate: 69.33, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromDate( 69.66, pULong );
printf( "VarUI4FromDate: 69.66, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromDate( -69.33, pULong );
printf( "VarUI4FromDate: -69.33, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromDate( -69.66, pULong );
printf( "VarUI4FromDate: -69.66, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromBool( VARIANT_TRUE, pULong );
printf( "VarUI4FromBool: VARIANT_TRUE, %lu, %X\n", *pULong, (unsigned int) res );
res = VarUI4FromBool( VARIANT_FALSE, pULong );
printf( "VarUI4FromBool: VARIANT_FALSE, %lu, %X\n", *pULong, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarUI4FromStr( pOleChar[olePtrIndex], 0, 0, pULong );
printf( "VarUI4FromStr: %s, %lu, %X\n", WtoA(pOleChar[olePtrIndex]), *pULong, (unsigned int) res );
}
/* CHAR from ...
*/
printf( "\n\n======== Testing VarI1FromXXX ========\n");
res = VarI1FromBool( VARIANT_TRUE, pByte );
printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pByte, (unsigned int) res );
res = VarI1FromBool( VARIANT_TRUE, pChar );
printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromBool( VARIANT_FALSE, pChar );
printf( "VarI1FromBool: VARIANT_FALSE, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromUI1( (unsigned char)32767, pChar );
printf( "VarI1FromUI1: 32767, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromUI1( (unsigned char)65535, pChar );
printf( "VarI1FromUI1: 65535, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromI4( 32767, pChar );
printf( "VarI1FromI4: 32767, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromI4( 32768, pChar );
printf( "VarI1FromI4: 32768, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromI4( -32768, pChar );
printf( "VarI1FromI4: -32768, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromI4( -32769, pChar );
printf( "VarI1FromI4: -32769, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromR8( 69.33, pChar );
printf( "VarI1FromR8: 69.33, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromR8( 69.66, pChar );
printf( "VarI1FromR8: 69.66, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromR8( -69.33, pChar );
printf( "VarI1FromR8: -69.33, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromR8( -69.66, pChar );
printf( "VarI1FromR8: -69.66, %d, %X\n", *pChar, (unsigned int) res );
res = VarI1FromDate( -69.66, pChar );
printf( "VarI1FromDate: -69.66, %d, %X\n", *pChar, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarI1FromStr( pOleChar[olePtrIndex], 0, 0, pChar );
printf( "VarI1FromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pChar, (unsigned int) res );
}
/* short from ...
*/
printf( "\n\n======== Testing VarI2FromXXX ========\n");
res = VarI2FromUI2( 32767, pShort );
printf( "VarI2FromUI2: 32767, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromUI2( 65535, pShort );
printf( "VarI2FromUI2: 65535, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromI4( 32767, pShort );
printf( "VarI2FromI4: 32767, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromI4( 32768, pShort );
printf( "VarI2FromI4: 32768, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromI4( -32768, pShort );
printf( "VarI2FromI4: -32768, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromI4( -32769, pShort );
printf( "VarI2FromI4: -32769, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromR8( 69.33, pShort );
printf( "VarI2FromR8: 69.33, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromR8( 69.66, pShort );
printf( "VarI2FromR8: 69.66, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromR8( -69.33, pShort );
printf( "VarI2FromR8: -69.33, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromR8( -69.66, pShort );
printf( "VarI2FromR8: -69.66, %d, %X\n", *pShort, (unsigned int) res );
res = VarI2FromDate( -69.66, pShort );
printf( "VarI2FromDate: -69.66, %d, %X\n", *pShort, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarI2FromStr( pOleChar[olePtrIndex], 0, 0, pShort );
printf( "VarI2FromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pShort, (unsigned int) res );
}
/* long from ...
*/
printf( "\n\n======== Testing VarI4FromXXX ========\n");
res = VarI4FromI2( 3, (long*)pInt );
printf( "VarIntFromI2: 3, %d, %X\n", *pInt, (unsigned int) res );
res = VarI4FromR8( 69.33, pLong );
printf( "VarI4FromR8: 69.33, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( 69.66, pLong );
printf( "VarI4FromR8: 69.66, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( -69.33, pLong );
printf( "VarI4FromR8: -69.33, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( -69.66, pLong );
printf( "VarI4FromR8: -69.66, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( 2147483647.0, pLong );
printf( "VarI4FromR8: 2147483647.0, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( 2147483648.0, pLong );
printf( "VarI4FromR8: 2147483648.0, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( -2147483647.0, pLong );
printf( "VarI4FromR8: -2147483647.0, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( -2147483648.0, pLong );
printf( "VarI4FromR8: -2147483648.0, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromR8( -2147483649.0, pLong );
printf( "VarI4FromR8: -2147483649.0, %ld, %X\n", *pLong, (unsigned int) res );
res = VarI4FromDate( -2147483649.0, pLong );
printf( "VarI4FromDate: -2147483649.0, %ld, %X\n", *pLong, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarI4FromStr( pOleChar[olePtrIndex], 0, 0, pLong );
printf( "VarI4FromStr: %s, %ld, %X\n", WtoA(pOleChar[olePtrIndex]), *pLong, (unsigned int) res );
}
/* float from ...
*/
printf( "\n\n======== Testing VarR4FromXXX ========\n");
res = VarR4FromI4( 16777216, pFloat );
printf( "VarR4FromI4: 16777216, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromI4( 16777217, pFloat );
printf( "VarR4FromI4: 16777217, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromI4( -16777216, pFloat );
printf( "VarR4FromI4: -16777216, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromI4( -16777217, pFloat );
printf( "VarR4FromI4: -16777217, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( 16777216.0, pFloat );
printf( "VarR4FromR8: 16777216.0, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( 16777217.0, pFloat );
printf( "VarR4FromR8: 16777217.0, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( -16777216.0, pFloat );
printf( "VarR4FromR8: -16777216.0, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( -16777217.0, pFloat );
printf( "VarR4FromR8: -16777217.0, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( 16777218e31, pFloat );
printf( "VarR4FromR8: 16777218e31, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromR8( 16777218e32, pFloat );
printf( "VarR4FromR8: 16777218e32, %f, %X\n", *pFloat, (unsigned int) res );
res = VarR4FromDate( 16777218e31, pFloat );
printf( "VarR4FromDate: 16777218e31, %f, %X\n", *pFloat, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarR4FromStr( pOleChar[olePtrIndex], 0, 0, pFloat );
printf( "VarR4FromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pFloat, (unsigned int) res );
}
/* double from ...
*/
printf( "\n\n======== Testing VarR8FromXXX ========\n");
res = VarR8FromDate( 900719925474099.0, pDouble );
printf( "VarR8FromDate: 900719925474099.0, %f, %X\n", *pDouble, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarR8FromStr( pOleChar[olePtrIndex], 0, 0, pDouble );
printf( "VarR8FromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pDouble, (unsigned int) res );
}
/* date from ...
*/
printf( "\n\n======== Testing VarDateFromXXX ========\n");
res = VarDateFromI4( 2958465, pDouble );
printf( "VarDateFromI4: 2958465, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromI4( 2958466, pDouble );
printf( "VarDateFromI4: 2958466, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromI4( -657434, pDouble );
printf( "VarDateFromI4: -657434, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromI4( -657435, pDouble );
printf( "VarDateFromI4: -657435, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( 2958465.9999, pDouble );
printf( "VarDateFromR8: 2958465.9999, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( 2958466, pDouble );
printf( "VarDateFromR8: 2958466, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( -657434.9999, pDouble );
printf( "VarDateFromR8: -657434.9999, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( -657435, pDouble );
printf( "VarDateFromR8: -657435, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( 0.0, pDouble );
printf( "VarDateFromR8: 0.0, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( 1.0, pDouble );
printf( "VarDateFromR8: 1.0, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( 2.25, pDouble );
printf( "VarDateFromR8: 2.25, %f, %X\n", *pDouble, (unsigned int) res );
res = VarDateFromR8( -2.0, pDouble );
printf( "VarDateFromR8: -2.0, %f, %X\n", *pDouble, (unsigned int) res );
/* Need some parsing function in Linux to emulate this...
* Still in progess.
*/
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarDateFromStr( pOleChar[olePtrIndex], 0, 0, pDouble );
printf( "VarDateFromStr: %s, %f, %X\n", WtoA(pOleChar[olePtrIndex]), *pDouble, (unsigned int) res );
}
/* bool from ...
*/
printf( "\n\n======== Testing VarBoolFromXXX ========\n");
res = VarBoolFromI4( 0, pBool );
printf( "VarBoolFromI4: 0, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromI4( 1, pBool );
printf( "VarBoolFromI4: 1, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromI4( -1, pBool );
printf( "VarBoolFromI4: -1, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromI4( 2, pBool );
printf( "VarBoolFromI4: 2, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromUI1( ' ', pBool );
printf( "VarBoolFromUI1: ' ', %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromUI1( '\0', pBool );
printf( "VarBoolFromUI1: '\\0', %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromUI1( 0x0000, pBool );
printf( "VarBoolFromUI1: 0x0000, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromUI1( (unsigned char)0xFFF, pBool );
printf( "VarBoolFromUI1: 0xFFF, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromUI1( (unsigned char)0xFFFF, pBool );
printf( "VarBoolFromUI1: 0xFFFF, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( 0.0, pBool );
printf( "VarBoolFromR8: 0.0, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( 1.1, pBool );
printf( "VarBoolFromR8: 1.1, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( 0.5, pBool );
printf( "VarBoolFromR8: 0.5, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( 0.49, pBool );
printf( "VarBoolFromR8: 0.49, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( 0.51, pBool );
printf( "VarBoolFromR8: 0.51, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( -0.5, pBool );
printf( "VarBoolFromR8: -0.5, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( -0.49, pBool );
printf( "VarBoolFromR8: -0.49, %d, %X\n", *pBool, (unsigned int) res );
res = VarBoolFromR8( -0.51, pBool );
printf( "VarBoolFromR8: -0.51, %d, %X\n", *pBool, (unsigned int) res );
for( olePtrIndex = 0; olePtrIndex < nOlePtrs; olePtrIndex ++ )
{
res = VarBoolFromStr( pOleChar[olePtrIndex], 0, 0, pBool );
printf( "VarBoolFromStr: %s, %d, %X\n", WtoA(pOleChar[olePtrIndex]), *pBool, (unsigned int) res );
}
res = VarI1FromBool( VARIANT_TRUE, pByte );
printf( "VarI1FromBool: VARIANT_TRUE, %d, %X\n", *pByte, (unsigned int) res );
res = VarUI2FromI2( -1, &i );
printf( "VarUI2FromI2: -1, %d, %X\n", i, (unsigned int) res );
/* BSTR from ...
*/
printf( "\n\n======== Testing VarBSTRFromXXX ========\n");
/* integers...
*/
res = VarBstrFromI1( -100, 0, 0, &bstr );
printf( "VarBstrFromI1: -100, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromUI1( 0x5A, 0, 0, &bstr );
printf( "VarBstrFromUI1: 0x5A, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromI4( 2958465, 0, 0, &bstr );
printf( "VarBstrFromI4: 2958465, %s, %X\n", WtoA( bstr ), (unsigned int) res );
/* reals...
*/
d=0;
for( i=0; i<20; i++ )
{
/* add an integer to the real number
*/
d += ((i%9)+1) * pow( 10, i );
res = VarBstrFromR8( d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR8( -d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
d=0;
for( i=0; i<20; i++ )
{
/* add a decimal to the real number
*/
d += ((i%9)+1) * pow( 10, (i*-1) );
res = VarBstrFromR8( d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR8( d-1, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", d-1, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR8( -d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
d=0;
for( i=0; i<20; i++ )
{
/* add an integer to the real number
*/
d += ((i%9)+1) * pow( 10, i );
/* add a decimal to the real number
*/
d += ((i%9)+1) * pow( 10, (i*-1) );
res = VarBstrFromR8( d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int)res );
res = VarBstrFromR8( -d, 0, 0, &bstr );
printf( "VarBstrFromR8: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
d=0;
for( i=0; i<10; i++ )
{
/* add an integer to the real number
*/
d += ((i%9)+1) * pow( 10, i );
res = VarBstrFromR4( (float)d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
d=0;
for( i=0; i<10; i++ )
{
/* add a decimal to the real number
*/
d += ((i%9)+1) * pow( 10, (i*-1) );
res = VarBstrFromR4( (float)d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR4( (float)d-1, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", d-1, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
d=0;
for( i=0; i<10; i++ )
{
/* add an integer to the real number
*/
d += ((i%9)+1) * pow( 10, i );
/* add a decimal to the real number
*/
d += ((i%9)+1) * pow( 10, (i*-1) );
res = VarBstrFromR4( (float)d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", d, WtoA( bstr ), (unsigned int) res );
res = VarBstrFromR4( (float)-d, 0, 0, &bstr );
printf( "VarBstrFromR4: %f, %s, %X\n", -d, WtoA( bstr ), (unsigned int) res );
}
res = VarBstrFromBool( 0x00, 0, 0, &bstr );
printf( "VarBstrFromBool: 0x00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromBool( 0xFF, 0, 0, &bstr );
printf( "VarBstrFromBool: 0xFF, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 0.0, 0, 0, &bstr );
printf( "VarBstrFromDate: 0.0, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 3.34, 0, 0, &bstr );
printf( "VarBstrFromDate: 3.34, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 3339.34, 0, 0, &bstr );
printf( "VarBstrFromDate: 3339.34, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 365.00, 0, 0, &bstr );
printf( "VarBstrFromDate: 365.00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 365.25, 0, 0, &bstr );
printf( "VarBstrFromDate: 365.25, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 1461.0, 0, 0, &bstr );
printf( "VarBstrFromDate: 1461.00, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromDate( 1461.5, 0, 0, &bstr );
printf( "VarBstrFromDate: 1461.5, %s, %X\n", WtoA( bstr ), (unsigned int) res );
res = VarBstrFromBool( 0x00, 0, 0, &bstr );
printf( "VarBstrFromBool: 0x00, %s, %X\n", WtoA(bstr), (unsigned int) res );
res = VarBstrFromBool( 0xFF, 0, 0, &bstr );
printf( "VarBstrFromBool: 0xFF, %s, %X\n", WtoA(bstr), (unsigned int) res );
res = VarBstrFromDate( 0.0, 0, 0, &bstr );
printf( "VarBstrFromDate: 0.0, %s, %X\n", WtoA(bstr), (unsigned int) res );
res = VarBstrFromDate( 3.34, 0, 0, &bstr );
printf( "VarBstrFromDate: 3.34, %s, %X\n", WtoA(bstr), (unsigned int) res );
/* Test variant API...
*/
printf( "\n\n======== Testing Hi-Level Variant API ========\n");
bstr = SysAllocString( pOleChar[4] );
res = VariantClear( &va );
printf( "Result is: %x\n", (unsigned int)res );
VariantInit( &va );
VariantInit( &vb );
VariantInit( &vc );
VariantInit( &vd );
VariantInit( &ve );
va.vt = VT_BSTR;
va.u.bstrVal = bstr;
res = VariantClear( &va );
printf( "VariantClear: %x\n", (unsigned int)res );
printf( "VariantClear: %x\n", (unsigned int)res );
SysFreeString( bstr );
SysFreeString( bstr );
res = VariantCopy( &vb, &va );
printf( "VariantCopy: %x\n", (unsigned int)res );
res = VariantClear( &vb );
printf( "VariantClear: %x\n", (unsigned int)res );
res = VariantClear( &va );
printf( "VariantClear: %x\n", (unsigned int)res );
va.vt = VT_R8;
d = 4.123;
va.u.dblVal = d;
res = VariantCopy( &va, &va );
printf( "VariantCopy %f -> %f: %x\n", V_R8(&va), V_R8(&va), (unsigned int)res );
va.vt = VT_R8 | VT_BYREF;
d = 31.123;
va.u.pdblVal = &d;
res = VariantCopyInd( &va, &va );
printf( "VariantCopyInd %f: %x\n", V_R8(&va), (unsigned int)res );
va.vt = VT_R8;
d = 1.123;
va.u.dblVal = d;
res = VariantCopy( &vb, &va );
printf( "VariantCopy %f -> %f: %x\n", V_R8(&va), V_R8(&vb), (unsigned int)res );
va.vt = VT_R8 | VT_BYREF;
d = 123.123;
va.u.pdblVal = &d;
res = VariantCopy( &vb, &va );
printf( "VariantCopy %f -> %f: %x\n", *(V_R8REF(&va)), *(V_R8REF(&vb)), (unsigned int)res );
va.vt = VT_R8 | VT_BYREF;
d = 111.2;
va.u.pdblVal = &d;
res = VariantCopyInd( &vb, &va );
printf( "VariantCopyInd %f -> %f: %x\n", *(V_R8REF(&va)), V_R8(&vb), (unsigned int)res );
va.vt = VT_R8 | VT_BYREF;
d = 1211.123453;
va.u.pdblVal = &d;
res = VariantChangeTypeEx( &va, &va, 0, 0, VT_I2 );
printf( "VariantChangeTypeEx %d: %x\n", V_I2(&va), (unsigned int) res );
va.vt = VT_INT;
va.u.intVal = 4;
res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR );
printf( "VariantChangeTypeEx %d -> %s: %x\n", V_INT(&va), WtoA(V_BSTR(&vb)), (unsigned int)res );
va.vt = VT_DATE;
va.u.date = 34465.332431;
res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_BSTR );
printf( "VariantChangeTypeEx %f -> %s: %x\n", V_DATE(&va), WtoA(V_BSTR(&vb)), (unsigned int)res );
bstr = pOleChar[4];
va.vt = VT_BSTR;
va.u.bstrVal = bstr;
res = VariantChangeTypeEx(&vb, &va, 0, 0, VT_R8 );
printf( "VariantChangeTypeEx %s -> %f: %x\n", WtoA(V_BSTR(&va)), V_R8(&vb), (unsigned int)res );
vc.vt = VT_BSTR | VT_BYREF;
vc.u.pbstrVal = &bstr;
vb.vt = VT_VARIANT | VT_BYREF;
vb.u.pvarVal = &vc;
va.vt = VT_VARIANT | VT_BYREF;
va.u.pvarVal = &vb;
res = VariantCopyInd( &vd, &va );
printf( "VariantCopyInd: %x\n", (unsigned int)res );
/* test what happens when bad vartypes are passed in
*/
printf( "-------------- Testing different VARTYPES ----------------\n" );
for( i=0; i<100; i++ )
{
/* Trying to use variants that are set to be BSTR but
* do not contain a valid pointer makes the program crash
* in Windows so we will skip those. We do not need them
* anyways to illustrate the behavior.
*/
if( i == VT_BSTR )
i = 77;
va.vt = i;
d = 4.123;
va.u.dblVal = d;
res = VariantCopyInd( &vb, &va );
printf( "VariantCopyInd: %d -> %x\n", i, (unsigned int)res );
va.vt = i | VT_BYREF;
d = 4.123;
va.u.pdblVal = &d;
res = VariantCopyInd( &vb, &va );
printf( "VariantCopyInd: %d -> %x\n", i, (unsigned int)res );
va.vt = VT_R8;
d = 4.123;
va.u.dblVal = d;
res = VariantChangeTypeEx( &vb, &va, 0, 0, i );
printf( "VariantChangeTypeEx: %d -> %x\n", i, (unsigned int)res );
va.vt = VT_R8;
d = 4.123;
va.u.dblVal = d;
res = VariantChangeTypeEx( &vb, &va, 0, 0, i | VT_BYREF );
printf( "VariantChangeTypeEx: VT_BYREF %d -> %x\n", i, (unsigned int)res );
va.vt = 99;
d = 4.123;
va.u.dblVal = d;
res = VariantClear( &va );
printf( "VariantClear: %d -> %x\n", i, (unsigned int)res );
}
res = VariantClear( &va );
printf( "VariantClear: %x\n", (unsigned int)res );
res = VariantClear( &vb );
printf( "VariantClear: %x\n", (unsigned int)res );
res = VariantClear( &vc );
printf( "VariantClear: %x\n", (unsigned int)res );
res = VariantClear( &vd );
printf( "VariantClear: %x\n", (unsigned int)res );
res = VariantClear( &ve );
printf( "VariantClear: %x\n", (unsigned int)res );
/* There is alot of memory leaks but this is simply a test program.
*/
return 0;
}
Reference in a new issue View git blame Copy permalink