* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
-#include <stdarg.h>
+#define WIN32_NO_STATUS
+#define _INC_WINDOWS
+#define COM_NO_WINDOWS_H
+
+//#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <float.h>
+#define COBJMACROS
#define CONST_VTABLE
-#include "windef.h"
-#include "winbase.h"
-#include "winsock.h"
-#include "wine/test.h"
-#include "winuser.h"
-#include "wingdi.h"
-#include "winnls.h"
-#include "winerror.h"
-#include "winnt.h"
-
-#include "wtypes.h"
-#include "oleauto.h"
+//#include "windef.h"
+//#include "winbase.h"
+//#include "winsock.h"
+#include <wine/test.h>
+//#include "winuser.h"
+//#include "wingdi.h"
+#include <winnls.h>
+//#include "winerror.h"
+//#include "winnt.h"
+#include <objbase.h>
+//#include "wtypes.h"
+#include <oleauto.h>
static HMODULE hOleaut32;
#define CHECKPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func); \
if (!p##func) { win_skip("function " # func " not available, not testing it\n"); return; }
-/* Have IRecordInfo data type? */
-static int HAVE_OLEAUT32_RECORD = 0;
-/* Have I8/UI8 data type? */
-static int HAVE_OLEAUT32_I8 = 0;
-/* Is this an ancient version with support for only I2/I4/R4/R8/DATE? */
-static int IS_ANCIENT = 0;
+/* Has I8/UI8 data type? */
+static BOOL has_i8;
/* When comparing floating point values we cannot expect an exact match
* because the rounding errors depend on the exact algorithm.
#define R8_MAX DBL_MAX
#define R8_MIN DBL_MIN
+#define DEFINE_EXPECT(func) \
+ static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
+
+#define SET_EXPECT(func) \
+ do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
+
+#define CHECK_EXPECT2(func) \
+ do { \
+ ok(expect_ ##func, "unexpected call " #func "\n"); \
+ called_ ## func = TRUE; \
+ }while(0)
+
+#define CHECK_EXPECT(func) \
+ do { \
+ CHECK_EXPECT2(func); \
+ expect_ ## func = FALSE; \
+ }while(0)
+
+#define CHECK_CALLED(func) \
+ do { \
+ ok(called_ ## func, "expected " #func "\n"); \
+ expect_ ## func = called_ ## func = FALSE; \
+ }while(0)
+
+DEFINE_EXPECT(dispatch_invoke);
+
+typedef struct
+{
+ IDispatch IDispatch_iface;
+ VARTYPE vt;
+ HRESULT result;
+} DummyDispatch;
+
+static inline DummyDispatch *impl_from_IDispatch(IDispatch *iface)
+{
+ return CONTAINING_RECORD(iface, DummyDispatch, IDispatch_iface);
+}
+
+static ULONG WINAPI DummyDispatch_AddRef(IDispatch *iface)
+{
+ return 2;
+}
+
+static ULONG WINAPI DummyDispatch_Release(IDispatch *iface)
+{
+ return 1;
+}
+
+static HRESULT WINAPI DummyDispatch_QueryInterface(IDispatch *iface,
+ REFIID riid,
+ void** ppvObject)
+{
+ *ppvObject = NULL;
+
+ if (IsEqualIID(riid, &IID_IDispatch) ||
+ IsEqualIID(riid, &IID_IUnknown))
+ {
+ *ppvObject = iface;
+ IDispatch_AddRef(iface);
+ }
+
+ return *ppvObject ? S_OK : E_NOINTERFACE;
+}
+
+static HRESULT WINAPI DummyDispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
+{
+ ok(0, "Unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DummyDispatch_GetTypeInfo(IDispatch *iface, UINT tinfo, LCID lcid, ITypeInfo **ti)
+{
+ ok(0, "Unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DummyDispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *names,
+ UINT cnames, LCID lcid, DISPID *dispid)
+{
+ ok(0, "Unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI DummyDispatch_Invoke(IDispatch *iface,
+ DISPID dispid, REFIID riid,
+ LCID lcid, WORD wFlags,
+ DISPPARAMS *params,
+ VARIANT *res,
+ EXCEPINFO *ei,
+ UINT *arg_err)
+{
+ DummyDispatch *This = impl_from_IDispatch(iface);
+
+ CHECK_EXPECT(dispatch_invoke);
+
+ ok(dispid == DISPID_VALUE, "got dispid %d\n", dispid);
+ ok(IsEqualIID(riid, &IID_NULL), "go riid %s\n", wine_dbgstr_guid(riid));
+ ok(wFlags == DISPATCH_PROPERTYGET, "Flags wrong\n");
+
+ ok(params->rgvarg == NULL, "got %p\n", params->rgvarg);
+ ok(params->rgdispidNamedArgs == NULL, "got %p\n", params->rgdispidNamedArgs);
+ ok(params->cArgs == 0, "got %d\n", params->cArgs);
+ ok(params->cNamedArgs == 0, "got %d\n", params->cNamedArgs);
+
+ ok(res != NULL, "got %p\n", res);
+ ok(V_VT(res) == VT_EMPTY, "got %d\n", V_VT(res));
+ ok(ei == NULL, "got %p\n", ei);
+ ok(arg_err == NULL, "got %p\n", arg_err);
+
+ if (FAILED(This->result))
+ return This->result;
+
+ V_VT(res) = This->vt;
+ if (This->vt == VT_UI1)
+ V_UI1(res) = 34;
+ else if (This->vt == VT_NULL)
+ {
+ V_VT(res) = VT_NULL;
+ V_BSTR(res) = NULL;
+ }
+ else
+ memset(res, 0, sizeof(*res));
+
+ return S_OK;
+}
+
+static const IDispatchVtbl DummyDispatch_VTable =
+{
+ DummyDispatch_QueryInterface,
+ DummyDispatch_AddRef,
+ DummyDispatch_Release,
+ DummyDispatch_GetTypeInfoCount,
+ DummyDispatch_GetTypeInfo,
+ DummyDispatch_GetIDsOfNames,
+ DummyDispatch_Invoke
+};
+
+static void init_test_dispatch(VARTYPE vt, DummyDispatch *dispatch)
+{
+ dispatch->IDispatch_iface.lpVtbl = &DummyDispatch_VTable;
+ dispatch->vt = vt;
+ dispatch->result = S_OK;
+}
+
+typedef struct IRecordInfoImpl
+{
+ IRecordInfo IRecordInfo_iface;
+ LONG ref;
+ unsigned int recordclear;
+ unsigned int getsize;
+ unsigned int recordcopy;
+ struct __tagBRECORD *rec;
+} IRecordInfoImpl;
+
+static inline IRecordInfoImpl *impl_from_IRecordInfo(IRecordInfo *iface)
+{
+ return CONTAINING_RECORD(iface, IRecordInfoImpl, IRecordInfo_iface);
+}
+
+static HRESULT WINAPI RecordInfo_QueryInterface(IRecordInfo *iface, REFIID riid, void **obj)
+{
+ *obj = NULL;
+
+ if (IsEqualIID(riid, &IID_IUnknown) ||
+ IsEqualIID(riid, &IID_IRecordInfo))
+ {
+ *obj = iface;
+ IRecordInfo_AddRef(iface);
+ return S_OK;
+ }
+
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI RecordInfo_AddRef(IRecordInfo *iface)
+{
+ IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
+ return InterlockedIncrement(&This->ref);
+}
+
+static ULONG WINAPI RecordInfo_Release(IRecordInfo *iface)
+{
+ IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
+ ULONG ref = InterlockedDecrement(&This->ref);
+
+ if (!ref)
+ HeapFree(GetProcessHeap(), 0, This);
+
+ return ref;
+}
+
+static HRESULT WINAPI RecordInfo_RecordInit(IRecordInfo *iface, PVOID pvNew)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_RecordClear(IRecordInfo *iface, void *data)
+{
+ IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
+ This->recordclear++;
+ This->rec->pvRecord = NULL;
+ return S_OK;
+}
+
+static HRESULT WINAPI RecordInfo_RecordCopy(IRecordInfo *iface, void *src, void *dest)
+{
+ IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
+ This->recordcopy++;
+ ok(src == (void*)0xdeadbeef, "wrong src pointer %p\n", src);
+ return S_OK;
+}
+
+static HRESULT WINAPI RecordInfo_GetGuid(IRecordInfo *iface, GUID *pguid)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_GetName(IRecordInfo *iface, BSTR *pbstrName)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_GetSize(IRecordInfo *iface, ULONG* size)
+{
+ IRecordInfoImpl* This = impl_from_IRecordInfo(iface);
+ This->getsize++;
+ *size = 0;
+ return S_OK;
+}
+
+static HRESULT WINAPI RecordInfo_GetTypeInfo(IRecordInfo *iface, ITypeInfo **ppTypeInfo)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_GetField(IRecordInfo *iface, PVOID pvData,
+ LPCOLESTR szFieldName, VARIANT *pvarField)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_GetFieldNoCopy(IRecordInfo *iface, PVOID pvData,
+ LPCOLESTR szFieldName, VARIANT *pvarField, PVOID *ppvDataCArray)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_PutField(IRecordInfo *iface, ULONG wFlags, PVOID pvData,
+ LPCOLESTR szFieldName, VARIANT *pvarField)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_PutFieldNoCopy(IRecordInfo *iface, ULONG wFlags,
+ PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_GetFieldNames(IRecordInfo *iface, ULONG *pcNames,
+ BSTR *rgBstrNames)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static BOOL WINAPI RecordInfo_IsMatchingType(IRecordInfo *iface, IRecordInfo *info2)
+{
+ ok(0, "unexpected call\n");
+ return FALSE;
+}
+
+static PVOID WINAPI RecordInfo_RecordCreate(IRecordInfo *iface)
+{
+ ok(0, "unexpected call\n");
+ return NULL;
+}
+
+static HRESULT WINAPI RecordInfo_RecordCreateCopy(IRecordInfo *iface, PVOID pvSource,
+ PVOID *ppvDest)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static HRESULT WINAPI RecordInfo_RecordDestroy(IRecordInfo *iface, PVOID pvRecord)
+{
+ ok(0, "unexpected call\n");
+ return E_NOTIMPL;
+}
+
+static const IRecordInfoVtbl RecordInfoVtbl =
+{
+ RecordInfo_QueryInterface,
+ RecordInfo_AddRef,
+ RecordInfo_Release,
+ RecordInfo_RecordInit,
+ RecordInfo_RecordClear,
+ RecordInfo_RecordCopy,
+ RecordInfo_GetGuid,
+ RecordInfo_GetName,
+ RecordInfo_GetSize,
+ RecordInfo_GetTypeInfo,
+ RecordInfo_GetField,
+ RecordInfo_GetFieldNoCopy,
+ RecordInfo_PutField,
+ RecordInfo_PutFieldNoCopy,
+ RecordInfo_GetFieldNames,
+ RecordInfo_IsMatchingType,
+ RecordInfo_RecordCreate,
+ RecordInfo_RecordCreateCopy,
+ RecordInfo_RecordDestroy
+};
+
+static IRecordInfoImpl *get_test_recordinfo(void)
+{
+ IRecordInfoImpl *rec;
+
+ rec = HeapAlloc(GetProcessHeap(), 0, sizeof(IRecordInfoImpl));
+ rec->IRecordInfo_iface.lpVtbl = &RecordInfoVtbl;
+ rec->ref = 1;
+ rec->recordclear = 0;
+ rec->getsize = 0;
+ rec->recordcopy = 0;
+
+ return rec;
+}
+
static void init(void)
{
BSTR bstr;
HRESULT res;
res = VarBstrFromBool(VARIANT_TRUE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
- ok(res == S_OK && (lstrlenW(bstr) > 0),
- "Expected localized string for 'True'\n");
+ ok(res == S_OK && bstr[0], "Expected localized string for 'True'\n");
/* lstrcpyW / lstrcatW do not work on win95 */
memcpy(sz12_true, sz12, sizeof(sz12));
if (bstr) memcpy(&sz12_true[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
SysFreeString(bstr);
res = VarBstrFromBool(VARIANT_FALSE, LANG_USER_DEFAULT, VAR_LOCALBOOL, &bstr);
- ok(res == S_OK && (lstrlenW(bstr) > 0),
- "Expected localized string for 'False'\n");
+ ok(res == S_OK && bstr[0], "Expected localized string for 'False'\n");
memcpy(sz12_false, sz12, sizeof(sz12));
if (bstr) memcpy(&sz12_false[2], bstr, SysStringByteLen(bstr) + sizeof(WCHAR));
SysFreeString(bstr);
- hOleaut32 = GetModuleHandle("oleaut32.dll");
-
- /* Is a given function exported from oleaut32? */
-#define HAVE_FUNC(func) ((void*)GetProcAddress(hOleaut32, #func) != NULL)
-
- HAVE_OLEAUT32_I8 = HAVE_FUNC(VarI8FromI1);
- if (!HAVE_OLEAUT32_I8)
- skip("No support for I8 and UI8 data types\n");
-
- HAVE_OLEAUT32_RECORD = HAVE_FUNC(SafeArraySetRecordInfo);
- IS_ANCIENT = (!HAVE_FUNC(VarI1FromI2));
-
-#undef HAVE_FUNC
+ hOleaut32 = GetModuleHandleA("oleaut32.dll");
+ has_i8 = GetProcAddress(hOleaut32, "VarI8FromI1") != NULL;
+ if (!has_i8)
+ skip("No support for I8 and UI8 data types\n");
}
/* Functions to set a DECIMAL */
S1(U1(*dec)).Lo32 = lo32;
}
-static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 )
-{
- while (*str1 && (*str1 == *str2)) { str1++; str2++; }
- return *str1 - *str2;
-}
-
/* return the string text of a given variant type */
static char vtstr_buffer[16][256];
static int vtstr_current=0;
return !memcmp( &V_DECIMAL(result), &V_DECIMAL(expected), sizeof(DECIMAL) );
default:
ok(0, "unhandled variant type %s\n",vtstr(V_VT(expected)));
- return 0;
+ return FALSE;
}
}
static void test_VariantInit(void)
{
- VARIANTARG v1, v2;
+ VARIANT v;
- /* Test that VariantInit() only sets the type */
- memset(&v1, -1, sizeof(v1));
- v2 = v1;
- V_VT(&v2) = VT_EMPTY;
- VariantInit(&v1);
- ok(!memcmp(&v1, &v2, sizeof(v1)), "VariantInit() set extra fields\n");
+ memset(&v, -1, sizeof(v));
+ VariantInit(&v);
+ ok(V_VT(&v) == VT_EMPTY, "VariantInit() returned vt %d\n", V_VT(&v));
}
/* All possible combinations of extra V_VT() flags */
};
/* Determine if a vt is valid for VariantClear() */
-static int IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
+static BOOL IsValidVariantClearVT(VARTYPE vt, VARTYPE extraFlags)
{
- int ret = 0;
+ BOOL ret = FALSE;
/* Only the following flags/types are valid */
if ((vt <= VT_LPWSTR || vt == VT_RECORD || vt == VT_CLSID) &&
(!(extraFlags & (VT_BYREF|VT_ARRAY)) || vt > VT_NULL) &&
(extraFlags == 0 || extraFlags == VT_BYREF || extraFlags == VT_ARRAY ||
extraFlags == (VT_ARRAY|VT_BYREF)))
- ret = 1; /* ok */
+ ret = TRUE; /* ok */
- if ((vt == VT_RECORD && !HAVE_OLEAUT32_RECORD) ||
- ((vt == VT_I8 || vt == VT_UI8) && !HAVE_OLEAUT32_I8))
- ret = 0; /* Old versions of oleaut32 */
+ if (!has_i8 && (vt == VT_I8 || vt == VT_UI8))
+ ret = FALSE; /* Old versions of oleaut32 */
return ret;
}
static void test_VariantClear(void)
{
+ struct __tagBRECORD *rec;
+ IRecordInfoImpl *recinfo;
HRESULT hres;
VARIANTARG v;
VARIANT v2;
V_VT(&v) = VT_UI4;
V_UI4(&v) = ~0u;
hres = VariantClear(&v);
- ok((hres == S_OK && V_VT(&v) == VT_EMPTY) ||
- (IS_ANCIENT && hres == DISP_E_BADVARTYPE && V_VT(&v) == VT_UI4),
+ ok((hres == S_OK && V_VT(&v) == VT_EMPTY),
"VariantClear: Type set to %d, res %08x\n", V_VT(&v), hres);
ok(V_UI4(&v) == ~0u, "VariantClear: Overwrote value\n");
* Also demonstrates that null pointers in 'v' are not dereferenced.
* Individual variant tests should test VariantClear() with non-NULL values.
*/
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
VARTYPE vt;
/* DISPATCH */
V_VT(&v) = VT_DISPATCH;
- V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl;
+ V_DISPATCH(&v) = (IDispatch*)&test_myVariantClearImpl.IUnknown_iface;
test_myVariantClearImpl.events = 0;
hres = VariantClear(&v);
ok(hres == S_OK, "ret %08x\n", hres);
ok(V_VT(&v) == 0, "vt %04x\n", V_VT(&v));
- ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl, "dispatch %p\n", V_DISPATCH(&v));
+ ok(V_DISPATCH(&v) == (IDispatch*)&test_myVariantClearImpl.IUnknown_iface,
+ "dispatch %p\n", V_DISPATCH(&v));
/* Check that Release got called, but nothing else */
ok(test_myVariantClearImpl.events == 0x4, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
ok(V_DISPATCHREF(&v) == (IDispatch**)&punk, "dispatch ref %p\n", V_DISPATCHREF(&v));
/* Check that nothing got called */
ok(test_myVariantClearImpl.events == 0, "Unexpected call. events %08x\n", test_myVariantClearImpl.events);
+
+ /* RECORD */
+ recinfo = get_test_recordinfo();
+ V_VT(&v) = VT_RECORD;
+ rec = &V_UNION(&v, brecVal);
+ rec->pRecInfo = &recinfo->IRecordInfo_iface;
+ rec->pvRecord = (void*)0xdeadbeef;
+ recinfo->recordclear = 0;
+ recinfo->ref = 2;
+ recinfo->rec = rec;
+ hres = VariantClear(&v);
+ ok(hres == S_OK, "ret %08x\n", hres);
+ ok(rec->pvRecord == NULL, "got %p\n", rec->pvRecord);
+ ok(recinfo->recordclear == 1, "got %d\n", recinfo->recordclear);
+ ok(recinfo->ref == 1, "got %d\n", recinfo->ref);
+ IRecordInfo_Release(&recinfo->IRecordInfo_iface);
}
static void test_VariantCopy(void)
{
+ struct __tagBRECORD *rec;
+ IRecordInfoImpl *recinfo;
VARIANTARG vSrc, vDst;
VARTYPE vt;
size_t i;
*/
/* vSrc == vDst */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
memset(&vSrc, 0, sizeof(vSrc));
V_VT(&vSrc) = VT_UI1;
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
}
/* Test that VariantClear() checks vSrc for validity before copying */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
}
VariantClear(&vDst);
}
+
+ /* copy RECORD */
+ recinfo = get_test_recordinfo();
+
+ memset(&vDst, 0, sizeof(vDst));
+ V_VT(&vDst) = VT_EMPTY;
+
+ V_VT(&vSrc) = VT_RECORD;
+ rec = &V_UNION(&vSrc, brecVal);
+ rec->pRecInfo = &recinfo->IRecordInfo_iface;
+ rec->pvRecord = (void*)0xdeadbeef;
+
+ recinfo->recordclear = 0;
+ recinfo->recordcopy = 0;
+ recinfo->getsize = 0;
+ recinfo->rec = rec;
+ hres = VariantCopy(&vDst, &vSrc);
+ ok(hres == S_OK, "ret %08x\n", hres);
+
+ rec = &V_UNION(&vDst, brecVal);
+ ok(rec->pvRecord != (void*)0xdeadbeef && rec->pvRecord != NULL, "got %p\n", rec->pvRecord);
+ ok(rec->pRecInfo == &recinfo->IRecordInfo_iface, "got %p\n", rec->pRecInfo);
+ ok(recinfo->getsize == 1, "got %d\n", recinfo->recordclear);
+ ok(recinfo->recordcopy == 1, "got %d\n", recinfo->recordclear);
+
+ VariantClear(&vDst);
+ VariantClear(&vSrc);
}
/* Determine if a vt is valid for VariantCopyInd() */
-static int IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
+static BOOL IsValidVariantCopyIndVT(VARTYPE vt, VARTYPE extraFlags)
{
- int ret = 0;
+ BOOL ret = FALSE;
if ((extraFlags & VT_ARRAY) ||
(vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
!(extraFlags & (VT_VECTOR|VT_RESERVED))))
{
- ret = 1; /* ok */
+ ret = TRUE; /* ok */
}
return ret;
}
memset(buffer, 0, sizeof(buffer));
/* vSrc == vDst */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
if (ExtraFlags[i] & VT_ARRAY)
continue; /* Native crashes on NULL safearray */
if ((vt == VT_I8 || vt == VT_UI8) &&
ExtraFlags[i] == VT_BYREF)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK; /* Only valid if I8 is a known type */
}
else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
V_VT(&vSrc) = VT_UI1|VT_BYREF;
V_BYREF(&vSrc) = &buffer;
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
}
/* bad src */
- for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]) && !IS_ANCIENT; i++)
+ for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
if (ExtraFlags[i] & VT_ARRAY)
continue; /* Native crashes on NULL safearray */
if ((vt == VT_I8 || vt == VT_UI8) &&
ExtraFlags[i] == VT_BYREF)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK; /* Only valid if I8 is a known type */
}
else if (IsValidVariantCopyIndVT(vt, ExtraFlags[i]))
/* VB oct char bigger than 7 */
CONVERT("&o128", NUMPRS_HEX_OCT);
-/*
- Native versions 2.x of oleaut32 allow this to succeed: later versions and Wine don't
- EXPECTFAIL;
- EXPECTRGB(0,FAILDIG);
-*/
+ EXPECT(2,NUMPRS_HEX_OCT,0x40,4,3,0);
+ EXPECTRGB(0,1);
+ EXPECTRGB(1,2);
+ EXPECTRGB(3,FAILDIG);
+
/** NUMPRS_PARENS **/
/* Empty parens = error */
#define EXPECT_UI4(val) EXPECT_OK { EXPECT_TYPE(VT_UI4); \
ok(V_UI4(&vOut) == val, "Expected ui4 = %d, got %d\n", (ULONG)val, V_UI4(&vOut)); }
#define EXPECT_I8(high,low) EXPECT_OK { EXPECT_TYPE(VT_I8); \
- ok(V_I8(&vOut) == ((((LONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
+ ok(V_I8(&vOut) == ((((ULONG64)(high))<<32)|(low)), "Expected i8 = %x%08x, got %x%08x\n", \
(LONG)(high), (LONG)(low), (LONG)(V_I8(&vOut)>>32), (LONG)V_I8(&vOut) ); }
#define EXPECT_UI8(val) EXPECT_OK { EXPECT_TYPE(VT_UI8); \
ok(V_UI8(&vOut) == val, "Expected ui8 = 0x%x%08x, got 0x%x%08x\n", \
SETRGB(4, 0xf); SETRGB(5, 0xf); SETRGB(6, 0xf); SETRGB(7, 0xf);
SETRGB(8, 0xf); SETRGB(9, 0xf); SETRGB(10, 0xf); SETRGB(11, 0xf);
SETRGB(12, 0xf); SETRGB(13, 0xf); SETRGB(14, 0xf); SETRGB(15, 0xf);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
/* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
truncate the number to the smallest integer size requested:
SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
/* We cannot use INTEGER_VTBITS as WinXP and Win2003 are broken(?). They
truncate the number to the smallest integer size requested:
SETRGB(4, 0); SETRGB(5, 0); SETRGB(6, 0); SETRGB(7, 0);
SETRGB(8, 0); SETRGB(9, 0); SETRGB(10, 0); SETRGB(11, 0);
SETRGB(12, 0); SETRGB(13, 0); SETRGB(14, 0); SETRGB(15, 2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
CONVERT(16,0,0,16,4,0, VTBIT_I8); EXPECT_I8(0x80000000,0x00000002);
}
/* for DATE values 0.0 < x < 1.0, x and -x represent the same datetime */
/* but when converting to DATE, prefer the positive versions */
UD2T(30,12,1899,6,0,0,0,6,364,0,S_OK,0.25);
+
+ UD2T(1,1,1980,18,1,16,0,2,1,VAR_TIMEVALUEONLY,S_OK,0.7508796296296296);
+ UD2T(1,1,1980,18,1,16,0,2,1,VAR_DATEVALUEONLY,S_OK,29221.0);
+ UD2T(25,12,1899,6,0,0,0,1,359,VAR_TIMEVALUEONLY,S_OK,0.25);
+ UD2T(25,12,1899,6,0,0,0,1,359,VAR_DATEVALUEONLY,S_OK,-5.0);
+ UD2T(1,-1,1980,18,1,16,0,0,0,VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY,S_OK,0.7508796296296296);
}
static void test_st2dt(int line, WORD d, WORD m, WORD y, WORD h, WORD mn,
ST2DT(2,1,1980,0,0,0,0,TRUE,29222.0);
ST2DT(0,1,1980,0,0,0,0,TRUE,29220.0); /* Rolls back to 31 Dec 1899 */
ST2DT(1,13,1980,0,0,0,0,FALSE,29587.0); /* Fails on invalid month */
+ ST2DT(32,1,1980,0,0,0,0,FALSE,0.0); /* Fails on invalid day */
+ ST2DT(1,1,-1,0,0,0,0,FALSE,0.0); /* Fails on invalid year */
+ ST2DT(1,1,10000,0,0,0,0,FALSE,0.0); /* Fails on invalid year */
+ ST2DT(1,1,9999,0,0,0,0,TRUE,2958101.0); /* 9999 is last valid year */
ST2DT(31,12,90,0,0,0,0,TRUE,33238.0); /* 30 <= year < 100 is 1900+year */
ST2DT(1,1,30,0,0,0,0,TRUE,10959.0); /* 30 <= year < 100 is 1900+year */
ST2DT(1,1,29,0,0,0,0,TRUE,47119.0); /* 0 <= year < 30 is 2000+year */
V_VT(&vDst) = VT_EMPTY;
hres = pVarAbs(&v,&vDst);
- if (ExtraFlags[i] & (VT_ARRAY|VT_ARRAY) ||
+ if (ExtraFlags[i] & VT_ARRAY ||
(!ExtraFlags[i] && (vt == VT_UNKNOWN || vt == VT_BSTR ||
vt == VT_DISPATCH || vt == VT_ERROR || vt == VT_RECORD)))
{
hExpected = S_OK;
break;
case VT_I8: case VT_UI8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
hExpected = S_OK;
break;
case VT_RECORD:
- if (HAVE_OLEAUT32_RECORD)
- hExpected = DISP_E_TYPEMISMATCH;
+ hExpected = DISP_E_TYPEMISMATCH;
break;
case VT_UNKNOWN: case VT_BSTR: case VT_DISPATCH: case VT_ERROR:
hExpected = DISP_E_TYPEMISMATCH;
VARNOT(INT,1,I4,-2);
VARNOT(UINT,0,I4,-1);
VARNOT(UINT,1,I4,-2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARNOT(I8,1,I8,-2);
VARNOT(I8,0,I8,-1);
VARNOT(BSTR, (BSTR)szTrue, BOOL, VARIANT_FALSE);
VARNOT(BSTR, (BSTR)szFalse, BOOL, VARIANT_TRUE);
- V_VT(&v) = VT_DECIMAL;
S(U(*pdec)).sign = DECIMAL_NEG;
S(U(*pdec)).scale = 0;
pdec->Hi32 = 0;
{
if (leftvt == VT_RECORD && rightvt == VT_I8)
{
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
expectedhres = DISP_E_TYPEMISMATCH;
else
expectedhres = DISP_E_BADVARTYPE;
hres = pVarSub(&left, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_R8,
"VarSub: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
- ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0),
+ ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.0),
"VarSub: BSTR + BSTR, expected %f got %f\n", 0.0, V_R8(&result));
/* Manually test some VT_CY and VT_DECIMAL variants */
ok(hres == S_OK && V_VT(&result) == VT_CY,
"VarSub: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
hres = VarR8FromCy(V_CY(&result), &r);
- ok(hres == S_OK && EQ_DOUBLE(r, 4702),
+ ok(hres == S_OK && EQ_DOUBLE(r, 4702.0),
"VarSub: CY value %f, expected %f\n", r, (double)4720);
hres = pVarSub(&left, &dec, &result);
VARMOD(BSTR,R8,strNum0,10,I4,5);
VARMOD(I4,BSTR,125,strNum1,I4,5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARMOD(BOOL,I8,100,10,I8,0);
VARMOD(I1,I8,100,10,I8,0);
{
hexpected = DISP_E_BADVARTYPE;
} else if((l == VT_VARIANT) || (r == VT_VARIANT))
- {
- hexpected = DISP_E_BADVARTYPE;
- } else if(lFound && !rFound)
{
hexpected = DISP_E_BADVARTYPE;
} else if(!lFound && !rFound)
else
V_I4(&v2) = 10000;
- if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || HAVE_OLEAUT32_I8)
+ if ((l != VT_I8 && l != VT_UI8 && r != VT_I8 && r != VT_UI8) || has_i8)
{
hres = pVarMod(&v1,&v2,&vDst);
ok(hres == hexpected,
/* test some invalid types */
/*TODO: not testing VT_DISPATCH */
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARMOD2(I8,INT,100,10,EMPTY,0,DISP_E_TYPEMISMATCH);
}
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
- HRESULT bFail = TRUE;
+ BOOL bFail = TRUE;
SKIPTESTS(vt);
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
break;
}
VARFIX(UI1,1,UI1,1);
VARFIX(I2,-1,I2,-1);
VARFIX(I4,-1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARFIX(I8,-1,I8,-1);
}
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
- HRESULT bFail = TRUE;
+ BOOL bFail = TRUE;
SKIPTESTS(vt);
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
break;
}
VARINT(UI1,1,UI1,1);
VARINT(I2,-1,I2,-1);
VARINT(I4,-1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARINT(I8,-1,I8,-1);
}
for (vt = 0; vt <= VT_BSTR_BLOB; vt++)
{
- HRESULT bFail = TRUE;
+ BOOL bFail = TRUE;
SKIPTESTS(vt);
bFail = FALSE;
break;
case VT_I8:
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
bFail = FALSE;
}
VARNEG(I4,-((int)(~0u >> 1)) - 1,R8,-2147483648u);
VARNEG(I4,-1,I4,1);
VARNEG(I4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARNEG(I8,1,I8,-1);
VARNEG(I8,-1,I8,1);
VARXOR(EMPTY,0,I4,1,I4,1);
VARXOR(EMPTY,0,UI4,0,I4,0);
VARXOR(EMPTY,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(EMPTY,0,I8,0,I8,0);
VARXOR(EMPTY,0,I8,1,I8,1);
VARXOR(NULL,0,I4,1,NULL,0);
VARXOR(NULL,0,UI4,0,NULL,0);
VARXOR(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(NULL,0,I8,0,NULL,0);
VARXOR(NULL,0,I8,1,NULL,0);
VARXOR(BOOL,VARIANT_TRUE,DATE,-1,I4,0);
VARXOR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
VARXOR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(BOOL,VARIANT_TRUE,I8,-1,I8,0);
VARXOR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
VARXOR(I1,-1,DATE,-1,I4,0);
VARXOR(I1,-1,DATE,0,I4,-1);
VARXOR(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I1,-1,I8,-1,I8,0);
VARXOR(I1,-1,I8,0,I8,-1);
VARXOR(UI1,255,DATE,-1,I4,-256);
VARXOR(UI1,255,DATE,0,I4,255);
VARXOR(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI1,255,I8,-1,I8,-256);
VARXOR(UI1,255,I8,0,I8,255);
VARXOR(I2,-1,DATE,-1,I4,0);
VARXOR(I2,-1,DATE,0,I4,-1);
VARXOR(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I2,-1,I8,-1,I8,0);
VARXOR(I2,-1,I8,0,I8,-1);
VARXOR(UI2,65535,DATE,-1,I4,-65536);
VARXOR(UI2,65535,DATE,0,I4,65535);
VARXOR(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI2,65535,I8,-1,I8,-65536);
VARXOR(UI2,65535,I8,0,I8,65535);
VARXOR(I4,-1,DATE,-1,I4,0);
VARXOR(I4,-1,DATE,0,I4,-1);
VARXOR(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I4,-1,I8,-1,I8,0);
VARXOR(I4,-1,I8,0,I8,-1);
VARXOR(UI4,0xffffffff,DATE,-1,I4,0);
VARXOR(UI4,0xffffffff,DATE,0,I4,-1);
VARXOR(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(UI4,0xffffffff,I8,0,I8,0xffffffff);
VARXOR(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,0);
VARXOR(R4,-1,DATE,-1,I4,0);
VARXOR(R4,-1,DATE,0,I4,-1);
VARXOR(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(R4,-1,I8,-1,I8,0);
VARXOR(R4,-1,I8,0,I8,-1);
VARXOR(R8,-1,DATE,-1,I4,0);
VARXOR(R8,-1,DATE,0,I4,-1);
VARXOR(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(R8,-1,I8,-1,I8,0);
VARXOR(R8,-1,I8,0,I8,-1);
VARXOR(DATE,-1,DATE,-1,I4,0);
VARXOR(DATE,-1,DATE,0,I4,-1);
VARXOR(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(DATE,-1,I8,-1,I8,0);
VARXOR(DATE,-1,I8,0,I8,-1);
VARXORCY(DATE,-1,0,I4,-1);
VARXORCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARXOR(I8,-1,I8,-1,I8,0);
VARXOR(I8,-1,I8,0,I8,-1);
VAROR(EMPTY,0,I4,1,I4,1);
VAROR(EMPTY,0,UI4,0,I4,0);
VAROR(EMPTY,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(EMPTY,0,I8,0,I8,0);
VAROR(EMPTY,0,I8,1,I8,1);
VAROR(NULL,0,I4,1,I4,1);
VAROR(NULL,0,UI4,0,NULL,0);
VAROR(NULL,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(NULL,0,I8,0,NULL,0);
VAROR(NULL,0,I8,1,I8,1);
VAROR(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
VAROR(BOOL,VARIANT_TRUE,DATE,0,I4,-1);
VAROR(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
VAROR(BOOL,VARIANT_TRUE,I8,0,I8,-1);
VAROR(I1,-1,DATE,-1,I4,-1);
VAROR(I1,-1,DATE,0,I4,-1);
VAROR(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I1,-1,I8,-1,I8,-1);
VAROR(I1,-1,I8,0,I8,-1);
VAROR(UI1,255,DATE,-1,I4,-1);
VAROR(UI1,255,DATE,0,I4,255);
VAROR(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI1,255,I8,-1,I8,-1);
VAROR(UI1,255,I8,0,I8,255);
VAROR(I2,-1,DATE,-1,I4,-1);
VAROR(I2,-1,DATE,0,I4,-1);
VAROR(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I2,-1,I8,-1,I8,-1);
VAROR(I2,-1,I8,0,I8,-1);
VAROR(UI2,65535,DATE,-1,I4,-1);
VAROR(UI2,65535,DATE,0,I4,65535);
VAROR(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI2,65535,I8,-1,I8,-1);
VAROR(UI2,65535,I8,0,I8,65535);
VAROR(I4,-1,DATE,-1,I4,-1);
VAROR(I4,-1,DATE,0,I4,-1);
VAROR(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I4,-1,I8,-1,I8,-1);
VAROR(I4,-1,I8,0,I8,-1);
VAROR(UI4,0xffffffff,DATE,-1,I4,-1);
VAROR(UI4,0xffffffff,DATE,0,I4,-1);
VAROR(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(UI4,0xffffffff,I8,-1,I8,-1);
VAROR(UI4,0xffffffff,I8,0,I8,0xffffffff);
VAROR(R4,-1,DATE,-1,I4,-1);
VAROR(R4,-1,DATE,0,I4,-1);
VAROR(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(R4,-1,I8,-1,I8,-1);
VAROR(R4,-1,I8,0,I8,-1);
VAROR(R8,-1,DATE,-1,I4,-1);
VAROR(R8,-1,DATE,0,I4,-1);
VAROR(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(R8,-1,I8,-1,I8,-1);
VAROR(R8,-1,I8,0,I8,-1);
VAROR(DATE,-1,DATE,-1,I4,-1);
VAROR(DATE,-1,DATE,0,I4,-1);
VAROR(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(DATE,-1,I8,-1,I8,-1);
VAROR(DATE,-1,I8,0,I8,-1);
VARORCY(DATE,-1,0,I4,-1);
VARORCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAROR(I8,-1,I8,-1,I8,-1);
VAROR(I8,-1,I8,0,I8,-1);
VAREQV(UI1,1,UI1,1,UI1,255);
VAREQV(UI1,1,UI1,0,UI1,254);
VAREQV(UI1,0,UI1,1,UI1,254);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VAREQV(UI4,VARIANT_FALSE,I8,VARIANT_FALSE,I8,-1);
VAREQV(UI4,5,I8,19,I8,-23);
hres = pVarMul(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_CY, "VarMul: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
hres = VarR8FromCy(V_CY(&result), &r);
- ok(hres == S_OK && EQ_DOUBLE(r, 42399), "VarMul: CY value %f, expected %f\n", r, (double)42399);
+ ok(hres == S_OK && EQ_DOUBLE(r, 42399.0), "VarMul: CY value %f, expected %f\n", r, (double)42399);
hres = pVarMul(&left, &dec, &result);
ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarMul: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
hres = pVarAdd(&left, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_BSTR, "VarAdd: expected coerced type VT_BSTR, got %s!\n", vtstr(V_VT(&result)));
hres = VarR8FromStr(V_BSTR(&result), 0, 0, &r);
- ok(hres == S_OK && EQ_DOUBLE(r, 1212), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
+ ok(hres == S_OK && EQ_DOUBLE(r, 1212.0), "VarAdd: BSTR value %f, expected %f\n", r, (double)1212);
VariantClear(&result);
/* Manuly test some VT_CY and VT_DECIMAL variants */
hres = pVarAdd(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_CY, "VarAdd: expected coerced type VT_CY, got %s!\n", vtstr(V_VT(&result)));
hres = VarR8FromCy(V_CY(&result), &r);
- ok(hres == S_OK && EQ_DOUBLE(r, 4720), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
+ ok(hres == S_OK && EQ_DOUBLE(r, 4720.0), "VarAdd: CY value %f, expected %f\n", r, (double)4720);
hres = pVarAdd(&left, &dec, &result);
ok(hres == S_OK && V_VT(&result) == VT_DECIMAL, "VarAdd: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
static const WCHAR sz12_date[] = {'1','2','9','/','3','0','/','1','9','8','0','\0'};
static const WCHAR sz12_date_broken[] = {'1','2','9','/','3','0','/','8','0','\0'};
static const WCHAR sz_empty[] = {'\0'};
- TCHAR orig_date_format[128];
+ CHAR orig_date_format[128];
VARTYPE leftvt, rightvt, resultvt;
HRESULT hres;
HRESULT expected_error_num;
+ int cmp;
+ DummyDispatch dispatch;
CHECKPTR(VarCat);
/* Set date format for testing */
lcid = LOCALE_USER_DEFAULT;
- GetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
- SetLocaleInfo(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
+ GetLocaleInfoA(lcid,LOCALE_SSHORTDATE,orig_date_format,128);
+ SetLocaleInfoA(lcid,LOCALE_SSHORTDATE,"M/d/yyyy");
VariantInit(&left);
VariantInit(&right);
SKIPTESTS(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
if (leftvt == VT_NULL && rightvt == VT_NULL)
/* Determine the error code for the vt combination */
ok(hres == expected_error_num,
"VarCat: %d, %d returned error, 0x%X expected 0x%X.\n",
- leftvt, rightvt, expected_error_num, hres);
+ leftvt, rightvt, hres, expected_error_num);
/* Check types are correct */
ok(V_VT(&result) == resultvt,
"VarCat: EMPTY concat with EMPTY did not return empty VT_BSTR\n");
/* Restore original date format settings */
- SetLocaleInfo(lcid,LOCALE_SSHORTDATE,orig_date_format);
+ SetLocaleInfoA(lcid,LOCALE_SSHORTDATE,orig_date_format);
VariantClear(&left);
VariantClear(&right);
VariantClear(&result);
VariantClear(&expected);
+ /* Dispatch conversion */
+ init_test_dispatch(VT_NULL, &dispatch);
+ V_VT(&left) = VT_DISPATCH;
+ V_DISPATCH(&left) = &dispatch.IDispatch_iface;
+
+ SET_EXPECT(dispatch_invoke);
+ hres = VarCat(&left, &right, &result);
+ todo_wine ok(hres == S_OK, "got 0x%08x\n", hres);
+ ok(V_VT(&result) == VT_BSTR, "got %d\n", V_VT(&result));
+ ok(SysStringLen(V_BSTR(&result)) == 0, "got %d\n", SysStringLen(V_BSTR(&result)));
+ CHECK_CALLED(dispatch_invoke);
+
+ VariantClear(&left);
+ VariantClear(&right);
+ VariantClear(&result);
+
+ init_test_dispatch(VT_NULL, &dispatch);
+ V_VT(&right) = VT_DISPATCH;
+ V_DISPATCH(&right) = &dispatch.IDispatch_iface;
+
+ SET_EXPECT(dispatch_invoke);
+ hres = VarCat(&left, &right, &result);
+ todo_wine ok(hres == S_OK, "got 0x%08x\n", hres);
+ ok(V_VT(&result) == VT_BSTR, "got %d\n", V_VT(&result));
+ ok(SysStringLen(V_BSTR(&result)) == 0, "got %d\n", SysStringLen(V_BSTR(&result)));
+ CHECK_CALLED(dispatch_invoke);
+
+ VariantClear(&left);
+ VariantClear(&right);
+ VariantClear(&result);
+
+ init_test_dispatch(VT_UI1, &dispatch);
+ V_VT(&right) = VT_DISPATCH;
+ V_DISPATCH(&right) = &dispatch.IDispatch_iface;
+
+ V_VT(&left) = VT_BSTR;
+ V_BSTR(&left) = SysAllocString(sz12);
+ SET_EXPECT(dispatch_invoke);
+ hres = pVarCat(&left,&right,&result);
+ ok(hres == S_OK, "VarCat failed with error 0x%08x\n", hres);
+ CHECK_CALLED(dispatch_invoke);
+ ok(!strcmp_wa(V_BSTR(&result), "1234"), "got %s\n", wine_dbgstr_w(V_BSTR(&result)));
+
+ VariantClear(&left);
+ VariantClear(&right);
+ VariantClear(&result);
+
+ init_test_dispatch(VT_NULL, &dispatch);
+ dispatch.result = E_OUTOFMEMORY;
+ V_VT(&right) = VT_DISPATCH;
+ V_DISPATCH(&right) = &dispatch.IDispatch_iface;
+
+ SET_EXPECT(dispatch_invoke);
+ hres = VarCat(&left, &right, &result);
+ todo_wine ok(hres == E_OUTOFMEMORY, "got 0x%08x\n", hres);
+ CHECK_CALLED(dispatch_invoke);
+
+ VariantClear(&left);
+ VariantClear(&right);
+ VariantClear(&result);
+
/* Test boolean conversion */
V_VT(&left) = VT_BOOL;
V_BOOL(&left) = VARIANT_TRUE;
V_BSTR(&right) = SysAllocStringLen(NULL,0);
hres = pVarCat(&left, &right, &result);
ok(hres == S_OK, "VarCat failed: %08x\n", hres);
- if(!strcmp_wa(V_BSTR(&result), "True")) {
+ VariantClear(&right);
+
+ cmp = strcmp_wa(V_BSTR(&result), "True");
+ VariantClear(&result);
+ if(!cmp) {
V_VT(&right) = VT_BOOL;
V_BOOL(&right) = 100;
hres = pVarCat(&left, &right, &result);
VARTYPE i;
HRESULT hres;
+ CHECKPTR(VarAnd);
+
true_str = SysAllocString(szTrue);
false_str = SysAllocString(szFalse);
- CHECKPTR(VarAnd);
-
/* Test all possible flag/vt combinations & the resulting vt type */
for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
SKIPTESTAND(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
SKIPTESTAND(rightvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
else if (leftvt == VT_I4 || rightvt == VT_I4 ||
leftvt == VT_UINT || rightvt == VT_UINT ||
leftvt == VT_INT || rightvt == VT_INT ||
- leftvt == VT_UINT || rightvt == VT_UINT ||
leftvt == VT_R4 || rightvt == VT_R4 ||
leftvt == VT_R8 || rightvt == VT_R8 ||
leftvt == VT_CY || rightvt == VT_CY ||
VARAND(EMPTY,0,UI4,0,I4,0);
VARAND(EMPTY,0,UI4,1,I4,0);
VARAND(EMPTY,1,UI4,1,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(EMPTY,0,I8,0,I8,0);
VARAND(EMPTY,0,I8,1,I8,0);
VARAND(NULL,0,I4,1,NULL,0);
VARAND(NULL,0,UI4,0,I4,0);
VARAND(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(NULL,0,I8,0,I8,0);
VARAND(NULL,0,I8,1,NULL,0);
VARAND(BOOL,VARIANT_TRUE,DATE,-1,I4,-1);
VARAND(BOOL,VARIANT_TRUE,DATE,0,I4,0);
VARAND(BOOL,VARIANT_FALSE,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(BOOL,VARIANT_TRUE,I8,-1,I8,-1);
VARAND(BOOL,VARIANT_TRUE,I8,0,I8,0);
VARAND(I1,-1,DATE,-1,I4,-1);
VARAND(I1,-1,DATE,0,I4,0);
VARAND(I1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I1,-1,I8,-1,I8,-1);
VARAND(I1,-1,I8,0,I8,0);
VARAND(UI1,255,DATE,-1,I4,255);
VARAND(UI1,255,DATE,0,I4,0);
VARAND(UI1,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI1,255,I8,-1,I8,255);
VARAND(UI1,255,I8,0,I8,0);
VARAND(I2,-1,DATE,-1,I4,-1);
VARAND(I2,-1,DATE,0,I4,0);
VARAND(I2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I2,-1,I8,-1,I8,-1);
VARAND(I2,-1,I8,0,I8,0);
VARAND(UI2,65535,DATE,-1,I4,65535);
VARAND(UI2,65535,DATE,0,I4,0);
VARAND(UI2,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI2,65535,I8,-1,I8,65535);
VARAND(UI2,65535,I8,0,I8,0);
VARAND(I4,-1,DATE,-1,I4,-1);
VARAND(I4,-1,DATE,0,I4,0);
VARAND(I4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I4,-1,I8,-1,I8,-1);
VARAND(I4,-1,I8,0,I8,0);
VARAND(UI4,0xffffffff,DATE,-1,I4,-1);
VARAND(UI4,0xffffffff,DATE,0,I4,0);
VARAND(UI4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(UI4,0xffffffff,I8,0,I8,0);
VARAND(UI4,0,I8,0,I8,0);
VARAND(R4,-1,DATE,-1,I4,-1);
VARAND(R4,-1,DATE,0,I4,0);
VARAND(R4,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(R4,-1,I8,-1,I8,-1);
VARAND(R4,-1,I8,0,I8,0);
VARAND(R8,-1,DATE,-1,I4,-1);
VARAND(R8,-1,DATE,0,I4,0);
VARAND(R8,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(R8,-1,I8,-1,I8,-1);
VARAND(R8,-1,I8,0,I8,0);
VARAND(DATE,-1,DATE,-1,I4,-1);
VARAND(DATE,-1,DATE,0,I4,0);
VARAND(DATE,0,DATE,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(DATE,-1,I8,-1,I8,-1);
VARAND(DATE,-1,I8,0,I8,0);
VARANDCY(DATE,-1,0,I4,0);
VARANDCY(DATE,0,0,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARAND(I8,-1,I8,-1,I8,-1);
VARAND(I8,-1,I8,0,I8,0);
/* Determine return type */
else if ((leftvt == VT_NULL || rightvt == VT_NULL) &&
((leftvt != VT_I8 && leftvt != VT_UI8 &&
- rightvt != VT_I8 && rightvt != VT_UI8) || HAVE_OLEAUT32_I8))
+ rightvt != VT_I8 && rightvt != VT_UI8) || has_i8))
resvt = VT_NULL;
else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
leftvt == VT_I4 || leftvt == VT_R4 ||
leftvt == VT_DATE || leftvt == VT_BSTR ||
leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
(leftvt >= VT_I1 && leftvt <= VT_UI4) ||
- (HAVE_OLEAUT32_I8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
+ (has_i8 && (leftvt == VT_I8 || leftvt == VT_UI8)) ||
leftvt == VT_INT || leftvt == VT_UINT) &&
(rightvt == VT_EMPTY || rightvt == VT_I2 ||
rightvt == VT_I4 || rightvt == VT_R4 ||
rightvt == VT_DATE || rightvt == VT_BSTR ||
rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
(rightvt >= VT_I1 && rightvt <= VT_UI4) ||
- (HAVE_OLEAUT32_I8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
+ (has_i8 && (rightvt == VT_I8 || rightvt == VT_UI8)) ||
rightvt == VT_INT || rightvt == VT_UINT))
resvt = VT_R8;
else
VARPOW(EMPTY,0,UI1,3,R8,0.0);
VARPOW(EMPTY,0,UI2,3,R8,0.0);
VARPOW(EMPTY,0,UI4,3,R8,0.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(EMPTY,0,I8,3,R8,0.0);
VARPOW(EMPTY,0,UI8,3,R8,0.0);
VARPOW(NULL,0,UI1,3,NULL,0);
VARPOW(NULL,0,UI2,3,NULL,0);
VARPOW(NULL,0,UI4,3,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(NULL,0,I8,3,NULL,0);
VARPOW(NULL,0,UI8,3,NULL,0);
VARPOW(I2,2,UI1,3,R8,8.0);
VARPOW(I2,2,UI2,3,R8,8.0);
VARPOW(I2,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I2,2,I8,3,R8,8.0);
VARPOW(I2,2,UI8,3,R8,8.0);
VARPOW(I4,2,UI1,3,R8,8.0);
VARPOW(I4,2,UI2,3,R8,8.0);
VARPOW(I4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I4,2,I8,3,R8,8.0);
VARPOW(I4,2,UI8,3,R8,8.0);
VARPOW(R4,2,UI1,3,R8,8.0);
VARPOW(R4,2,UI2,3,R8,8.0);
VARPOW(R4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(R4,2,I8,3,R8,8.0);
VARPOW(R4,2,UI8,3,R8,8.0);
VARPOW(R8,2,UI1,3,R8,8.0);
VARPOW(R8,2,UI2,3,R8,8.0);
VARPOW(R8,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(R8,2,I8,3,R8,8.0);
VARPOW(R8,2,UI8,3,R8,8.0);
VARPOW(DATE,2,UI1,3,R8,8.0);
VARPOW(DATE,2,UI2,3,R8,8.0);
VARPOW(DATE,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(DATE,2,I8,3,R8,8.0);
VARPOW(DATE,2,UI8,3,R8,8.0);
VARPOW(BSTR,num2_str,UI1,3,R8,8.0);
VARPOW(BSTR,num2_str,UI2,3,R8,8.0);
VARPOW(BSTR,num2_str,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(BSTR,num2_str,I8,3,R8,8.0);
VARPOW(BSTR,num2_str,UI8,3,R8,8.0);
VARPOW(BOOL,VARIANT_TRUE,UI1,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI2,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI4,3,R8,-1.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(BOOL,VARIANT_TRUE,I8,3,R8,-1.0);
VARPOW(BOOL,VARIANT_TRUE,UI8,3,R8,-1.0);
VARPOW(I1,2,UI1,3,R8,8.0);
VARPOW(I1,2,UI2,3,R8,8.0);
VARPOW(I1,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I1,2,I8,3,R8,8.0);
VARPOW(I1,2,UI8,3,R8,8.0);
VARPOW(UI1,2,UI1,3,R8,8.0);
VARPOW(UI1,2,UI2,3,R8,8.0);
VARPOW(UI1,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI1,2,I8,3,R8,8.0);
VARPOW(UI1,2,UI8,3,R8,8.0);
VARPOW(UI2,2,UI1,3,R8,8.0);
VARPOW(UI2,2,UI2,3,R8,8.0);
VARPOW(UI2,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI2,2,I8,3,R8,8.0);
VARPOW(UI2,2,UI8,3,R8,8.0);
VARPOW(UI4,2,UI1,3,R8,8.0);
VARPOW(UI4,2,UI2,3,R8,8.0);
VARPOW(UI4,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UI4,2,I8,3,R8,8.0);
VARPOW(UI4,2,UI8,3,R8,8.0);
}
VARPOW(UI4,2,INT,3,R8,8.0);
VARPOW(UI4,2,UINT,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(I8,2,EMPTY,0,R8,1.0);
VARPOW(I8,2,NULL,0,NULL,0);
VARPOW(INT,2,UI1,3,R8,8.0);
VARPOW(INT,2,UI2,3,R8,8.0);
VARPOW(INT,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(INT,2,I8,3,R8,8.0);
VARPOW(INT,2,UI8,3,R8,8.0);
VARPOW(UINT,2,UI1,3,R8,8.0);
VARPOW(UINT,2,UI2,3,R8,8.0);
VARPOW(UINT,2,UI4,3,R8,8.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARPOW(UINT,2,I8,3,R8,8.0);
VARPOW(UINT,2,UI8,3,R8,8.0);
hres = pVarPow(&cy, &right, &result);
if (hres == S_OK)
{
- ok(hres == S_OK && V_VT(&result) == VT_R8,
+ ok(V_VT(&result) == VT_R8,
"VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
S_OK, hres, vtstr(V_VT(&result)));
- ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
+ ok(EQ_DOUBLE(V_R8(&result), 4.0),
"VARPOW: CY value %f, expected %f\n", V_R8(&result), 4.0);
}
else
hres = pVarPow(&dec, &right, &result);
if (hres == S_OK)
{
- ok(hres == S_OK && V_VT(&result) == VT_R8,
+ ok(V_VT(&result) == VT_R8,
"VARPOW: expected coerced hres 0x%X type VT_R8, got hres 0x%X type %s!\n",
S_OK, hres, vtstr(V_VT(&result)));
- ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 4.0),
+ ok(EQ_DOUBLE(V_R8(&result), 4.0),
"VARPOW: DECIMAL value %f, expected %f\n", V_R8(&result), 4.0);
}
else
HRESULT hres;
double r;
+ CHECKPTR(VarDiv);
+
num1_str = SysAllocString(str1);
num2_str = SysAllocString(str2);
- CHECKPTR(VarDiv);
-
/* Test all possible flag/vt combinations & the resulting vt type */
for (i = 0; i < sizeof(ExtraFlags)/sizeof(ExtraFlags[0]); i++)
{
SKIPTESTDIV(leftvt);
/* Check if we need/have support for I8 */
- if (leftvt == VT_I8 && !HAVE_OLEAUT32_I8)
+ if (leftvt == VT_I8 && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
SKIPTESTDIV(rightvt);
/* Check if we need/have support for I8 */
- if (rightvt == VT_I8 && !HAVE_OLEAUT32_I8)
+ if (rightvt == VT_I8 && !has_i8)
continue;
/* Native crashes with VT_BYREF */
}
/* Determine return type */
- if (!(rightvt == VT_EMPTY))
+ if (rightvt != VT_EMPTY)
{
if (leftvt == VT_NULL || rightvt == VT_NULL)
resvt = VT_NULL;
else if (leftvt == VT_R4 || rightvt == VT_R4)
resvt = VT_R4;
}
- else if (leftvt == VT_NULL && rightvt == VT_EMPTY)
+ else if (leftvt == VT_NULL)
resvt = VT_NULL;
else
bFail = TRUE;
VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
VARDIV(EMPTY,0,BOOL,VARIANT_TRUE,R8,0.0);
VARDIV(EMPTY,0,UI1,2,R8,0.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(EMPTY,0,I8,2,R8,0.0);
}
VARDIV(NULL,0,BSTR,num2_str,NULL,0);
VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
VARDIV(NULL,0,UI1,2,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(NULL,0,I8,2,NULL,0);
}
VARDIV(I2,1,DATE,2,R8,0.5);
VARDIV(I2,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(I2,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(I2,1,I8,2,R8,0.5);
}
VARDIV(I4,1,BSTR,num2_str,R8,0.5);
VARDIV(I4,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(I4,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(I4,1,I8,2,R8,0.5);
}
VARDIV(R4,1.0f,BSTR,num2_str,R8,0.5);
VARDIV(R4,1.0f,BOOL,VARIANT_TRUE,R4,-1);
VARDIV(R4,1.0f,UI1,2,R4,0.5f);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(R4,1.0f,I8,2,R8,0.5);
}
VARDIV(R8,1.0,BSTR,num2_str,R8,0.5);
VARDIV(R8,1.0,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(R8,1.0,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(R8,1.0,I8,2,R8,0.5);
}
VARDIV(DATE,1,BSTR,num2_str,R8,0.5);
VARDIV(DATE,1,BOOL,VARIANT_TRUE,R8,-1.0);
VARDIV(DATE,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(DATE,1,I8,2,R8,0.5);
}
VARDIV(BSTR,num1_str,BSTR,num2_str,R8,0.5);
VARDIV(BSTR,num1_str,BOOL,VARIANT_TRUE,R8,-1);
VARDIV(BSTR,num1_str,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(BSTR,num1_str,I8,2,R8,0.5);
}
VARDIV(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,R8,1.0);
VARDIV(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,R8,0.0);
VARDIV(BOOL,VARIANT_TRUE,UI1,1,R8,-1.0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
}
VARDIV(UI1,1,BSTR,num2_str,R8,0.5);
VARDIV(UI1,1,BOOL,VARIANT_TRUE,R8,-1);
VARDIV(UI1,1,UI1,2,R8,0.5);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARDIV(UI1,1,I8,2,R8,0.5);
VARDIV(I8,1,NULL,0,NULL,0);
SKIPTESTIDIV(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
VARIDIV(EMPTY,0,UI1,1,I2,0);
VARIDIV(EMPTY,0,UI2,1,I4,0);
VARIDIV(EMPTY,0,UI4,1,I4,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(EMPTY,0,I8,1,I8,0);
VARIDIV(EMPTY,0,UI8,1,I4,0);
VARIDIV(NULL,0,UI1,1,NULL,0);
VARIDIV(NULL,0,UI2,1,NULL,0);
VARIDIV(NULL,0,UI4,1,NULL,0);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(NULL,0,I8,1,NULL,0);
VARIDIV(NULL,0,UI8,1,NULL,0);
VARIDIV(I2,2,UI1,1,I2,2);
VARIDIV(I2,2,UI2,1,I4,2);
VARIDIV(I2,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I2,2,I8,1,I8,2);
VARIDIV(I2,2,UI8,1,I4,2);
VARIDIV(I4,2,UI1,1,I4,2);
VARIDIV(I4,2,UI2,1,I4,2);
VARIDIV(I4,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I4,2,I8,1,I8,2);
VARIDIV(I4,2,UI8,1,I4,2);
VARIDIV(R4,2.0f,UI1,1,I4,2);
VARIDIV(R4,2.0f,UI2,1,I4,2);
VARIDIV(R4,2.0f,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(R4,2.0f,I8,1,I8,2);
VARIDIV(R4,2.0f,UI8,1,I4,2);
VARIDIV(R8,2.0,UI1,1,I4,2);
VARIDIV(R8,2.0,UI2,1,I4,2);
VARIDIV(R8,2.0,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(R8,2.0,I8,1,I8,2);
VARIDIV(R8,2.0,UI8,1,I4,2);
VARIDIV(DATE,2,UI1,1,I4,2);
VARIDIV(DATE,2,UI2,1,I4,2);
VARIDIV(DATE,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(DATE,2,I8,1,I8,2);
VARIDIV(DATE,2,UI8,1,I4,2);
VARIDIV(BSTR,num2_str,UI1,1,I4,2);
VARIDIV(BSTR,num2_str,UI2,1,I4,2);
VARIDIV(BSTR,num2_str,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(BSTR,num2_str,I8,1,I8,2);
VARIDIV(BSTR,num2_str,UI8,1,I4,2);
VARIDIV(BOOL,VARIANT_TRUE,UI1,1,I2,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI2,1,I4,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(BOOL,VARIANT_TRUE,I8,1,I8,-1);
VARIDIV(BOOL,VARIANT_TRUE,UI8,1,I4,-1);
VARIDIV(I1,2,UI1,1,I4,2);
VARIDIV(I1,2,UI2,1,I4,2);
VARIDIV(I1,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I1,2,I8,1,I8,2);
VARIDIV(I1,2,UI8,1,I4,2);
VARIDIV(UI1,2,UI1,1,UI1,2);
VARIDIV(UI1,2,UI2,1,I4,2);
VARIDIV(UI1,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI1,2,I8,1,I8,2);
VARIDIV(UI1,2,UI8,1,I4,2);
VARIDIV(UI2,2,UI1,1,I4,2);
VARIDIV(UI2,2,UI2,1,I4,2);
VARIDIV(UI2,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI2,2,I8,1,I8,2);
VARIDIV(UI2,2,UI8,1,I4,2);
VARIDIV(UI4,2,UI1,1,I4,2);
VARIDIV(UI4,2,UI2,1,I4,2);
VARIDIV(UI4,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UI4,2,I8,1,I8,2);
VARIDIV(UI4,2,UI8,1,I4,2);
}
VARIDIV(UI4,2,INT,1,I4,2);
VARIDIV(UI4,2,UINT,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(I8,2,NULL,0,NULL,0);
VARIDIV(I8,2,I2,1,I8,2);
VARIDIV(INT,2,UI1,1,I4,2);
VARIDIV(INT,2,UI2,1,I4,2);
VARIDIV(INT,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(INT,2,UI8,1,I4,2);
}
VARIDIV(UINT,2,UI1,1,I4,2);
VARIDIV(UINT,2,UI2,1,I4,2);
VARIDIV(UINT,2,UI4,1,I4,2);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIDIV(UINT,2,I8,1,I8,2);
VARIDIV(UINT,2,UI8,1,I4,2);
ok(hres == S_OK && V_I4(&result) == 1,
"VARIDIV: CY value %d, expected %d\n", V_I4(&result), 1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarIdiv(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
ok(hres == S_OK && V_I4(&result) == 1,
"VARIDIV: DECIMAL value %d, expected %d\n", V_I4(&result), 1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarIdiv(&dec, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
SKIPTESTIMP(leftvt);
/* Check if we need/have support for I8 and/or UI8 */
- if ((leftvt == VT_I8 || leftvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((leftvt == VT_I8 || leftvt == VT_UI8) && !has_i8)
continue;
for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
continue;
/* Check if we need/have support for I8 and/or UI8 */
- if ((rightvt == VT_I8 || rightvt == VT_UI8) && !HAVE_OLEAUT32_I8)
+ if ((rightvt == VT_I8 || rightvt == VT_UI8) && !has_i8)
continue;
memset(&left, 0, sizeof(left));
VARIMP(EMPTY,0,UI1,1,I2,-1);
VARIMP(EMPTY,0,UI2,1,I4,-1);
VARIMP(EMPTY,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(EMPTY,0,I8,1,I8,-1);
VARIMP(EMPTY,0,UI8,1,I4,-1);
VARIMP(NULL,0,UI1,1,UI1,1);
VARIMP(NULL,0,UI2,1,I4,1);
VARIMP(NULL,0,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(NULL,0,I8,1,I8,1);
VARIMP(NULL,0,UI8,1,I4,1);
VARIMP(I2,-1,UI1,1,I2,1);
VARIMP(I2,-1,UI2,1,I4,1);
VARIMP(I2,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I2,-1,I8,1,I8,1);
VARIMP(I2,-1,UI8,1,I4,1);
VARIMP(I4,2,UI1,1,I4,-3);
VARIMP(I4,2,UI2,1,I4,-3);
VARIMP(I4,2,UI4,1,I4,-3);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I4,2,I8,1,I8,-3);
VARIMP(I4,2,UI8,1,I4,-3);
VARIMP(R4,-1.0f,UI1,1,I4,1);
VARIMP(R4,-1.0f,UI2,1,I4,1);
VARIMP(R4,-1.0f,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(R4,-1.0f,I8,1,I8,1);
VARIMP(R4,-1.0f,UI8,1,I4,1);
VARIMP(R8,1.0,UI1,1,I4,-1);
VARIMP(R8,1.0,UI2,1,I4,-1);
VARIMP(R8,1.0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(R8,1.0,I8,1,I8,-1);
VARIMP(R8,1.0,UI8,1,I4,-1);
VARIMP(DATE,0,UI1,1,I4,-1);
VARIMP(DATE,0,UI2,1,I4,-1);
VARIMP(DATE,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(DATE,0,I8,1,I8,-1);
VARIMP(DATE,0,UI8,1,I4,-1);
VARIMP(BSTR,false_str,UI1,1,I2,-1);
VARIMP(BSTR,false_str,UI2,1,I4,-1);
VARIMP(BSTR,false_str,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(BSTR,false_str,I8,1,I8,-1);
VARIMP(BSTR,false_str,UI8,1,I4,-1);
VARIMP(BOOL,VARIANT_TRUE,UI1,1,I2,1);
VARIMP(BOOL,VARIANT_TRUE,UI2,1,I4,1);
VARIMP(BOOL,VARIANT_TRUE,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(BOOL,VARIANT_TRUE,I8,1,I8,1);
VARIMP(BOOL,VARIANT_TRUE,UI8,1,I4,1);
VARIMP(I1,-1,UI1,1,I4,1);
VARIMP(I1,-1,UI2,1,I4,1);
VARIMP(I1,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I1,-1,I8,1,I8,1);
VARIMP(I1,-1,UI8,1,I4,1);
VARIMP(UI1,0,UI1,1,UI1,255);
VARIMP(UI1,0,UI2,1,I4,-1);
VARIMP(UI1,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI1,0,I8,1,I8,-1);
VARIMP(UI1,0,UI8,1,I4,-1);
VARIMP(UI2,0,UI1,1,I4,-1);
VARIMP(UI2,0,UI2,1,I4,-1);
VARIMP(UI2,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI2,0,I8,1,I8,-1);
VARIMP(UI2,0,UI8,1,I4,-1);
VARIMP(UI4,0,UI1,1,I4,-1);
VARIMP(UI4,0,UI2,1,I4,-1);
VARIMP(UI4,0,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UI4,0,I8,1,I8,-1);
VARIMP(UI4,0,UI8,1,I4,-1);
}
VARIMP(UI4,0,INT,-1,I4,-1);
VARIMP(UI4,0,UINT,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(I8,-1,EMPTY,0,I8,0);
VARIMP(I8,-1,NULL,0,NULL,0);
VARIMP(INT,-1,UI1,1,I4,1);
VARIMP(INT,-1,UI2,1,I4,1);
VARIMP(INT,-1,UI4,1,I4,1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(INT,-1,I8,1,I8,1);
VARIMP(INT,-1,UI8,1,I4,1);
VARIMP(UINT,1,UI1,1,I4,-1);
VARIMP(UINT,1,UI2,1,I4,-1);
VARIMP(UINT,1,UI4,1,I4,-1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
VARIMP(UINT,1,I8,1,I8,-1);
VARIMP(UINT,1,UI8,1,I4,-1);
ok(hres == S_OK && V_I4(&result) == -1,
"VARIMP: CY value %d, expected %d\n", V_I4(&result), -1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarImp(&cy, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
ok(hres == S_OK && V_I4(&result) == -1,
"VARIMP: DECIMAL value %d, expected %d\n", V_I4(&result), -1);
- if (HAVE_OLEAUT32_I8)
+ if (has_i8)
{
hres = pVarImp(&dec, &right, &result);
ok(hres == S_OK && V_VT(&result) == VT_I8,
projects / reactos.git / blobdiff