oleaut32 1/2: Conformance tests for function variant:VarDiv
Benjamin Arai
me at benjaminarai.com
Thu Aug 31 19:12:13 CDT 2006
Hi,
The two of patches add a conformance test and fixes to the variant
function VarDiv. The patches must be applied together because the
current implementation crashes on certain tests due to insufficient
handling of several variant types.
ChangeLog:
- Adds tests for error codes, variant types and result values for VarDiv
---
dlls/oleaut32/tests/vartest.c | 386 +++++++++++++++++++++++++++++++++++++++++
1 files changed, 386 insertions(+), 0 deletions(-)
Copyright: Google
License: LGPL
--
Benjamin Arai
http://www.benjaminarai.com
-------------- next part --------------
diff --git a/dlls/oleaut32/tests/vartest.c b/dlls/oleaut32/tests/vartest.c
index fc10c81..8c5f0b6 100644
--- a/dlls/oleaut32/tests/vartest.c
+++ b/dlls/oleaut32/tests/vartest.c
@@ -6290,6 +6290,391 @@ static void test_VarCmp(void)
SysFreeString(bstr1few);
}
+static HRESULT (WINAPI *pVarDiv)(LPVARIANT,LPVARIANT,LPVARIANT);
+
+static const char *szVarDivFail = "VarDiv(%s,%s): expected 0x0,%s,%d, got 0x%lX,%s,%d\n";
+
+#define VARDIV(vt1,val1,vt2,val2,rvt,rval) \
+ V_VT(&left) = VT_##vt1; V_VT(&right) = VT_##vt2; \
+ V_##vt1(&left) = val1; V_##vt2(&right) = val2; \
+ memset(&result,0,sizeof(result)); \
+ hres = pVarDiv(&left,&right,&result); \
+ ok(hres == S_OK && V_VT(&result) == VT_##rvt && \
+ EQ_DOUBLE(V_##rvt(&result),(rval)), \
+ szVarDivFail, vtstr(VT_##vt1), vtstr(VT_##vt2), \
+ vtstr(VT_##rvt), (int)(rval), hres, vtstr(V_VT(&result)), \
+ (int)V_##rvt(&result));
+
+static void test_VarDiv(test)
+{
+ static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
+ static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
+ static const WCHAR str2[] = { '2','\0' };
+ static const WCHAR str1[] = { '1','\0' };
+ VARIANT left, right, result, cy, dec;
+ BSTR false_str, true_str, num1_str, num2_str;
+ VARTYPE i;
+ HRESULT hres, expectedhres;
+ double r;
+
+ true_str = SysAllocString(szTrue);
+ false_str = SysAllocString(szFalse);
+ 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++)
+ {
+ VARTYPE leftvt, rightvt, resvt;
+
+ for (leftvt = 0; leftvt <= VT_BSTR_BLOB; leftvt++)
+ {
+ SKIPTESTS(leftvt);
+
+ for (rightvt = 0; rightvt <= VT_BSTR_BLOB; rightvt++)
+ {
+ SKIPTESTS(rightvt);
+
+ if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
+ leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
+ leftvt == VT_RECORD || rightvt == VT_RECORD)
+ continue;
+
+ memset(&left, 0, sizeof(left));
+ memset(&right, 0, sizeof(right));
+ V_VT(&left) = leftvt | ExtraFlags[i];
+ V_VT(&right) = rightvt | ExtraFlags[i];
+ V_VT(&result) = VT_EMPTY;
+ resvt = VT_EMPTY;
+ expectedhres = S_OK;
+
+ if (leftvt == VT_BSTR)
+ V_BSTR(&left) = num2_str;
+ else if (leftvt == VT_DECIMAL)
+ {
+ VarDecFromR8(2.0, &V_DECIMAL(&left));
+ V_VT(&left) = leftvt | ExtraFlags[i];
+ }
+
+ /* Division by 0 is undefined */
+ switch(rightvt)
+ {
+ case VT_BSTR:
+ V_BSTR(&right) = num2_str;
+ break;
+ case VT_DECIMAL:
+ VarDecFromR8(2.0, &V_DECIMAL(&right));
+ V_VT(&right) = rightvt | ExtraFlags[i];
+ break;
+ case VT_BOOL:
+ V_BOOL(&right) = VARIANT_TRUE;
+ break;
+ case VT_I2: V_I2(&right) = 2; break;
+ case VT_I4: V_I4(&right) = 2; break;
+ case VT_R4: V_R4(&right) = 2.0; break;
+ case VT_R8: V_R8(&right) = 2.0; break;
+ case VT_CY: V_CY(&right).int64 = 2; break;
+ case VT_DATE: V_DATE(&right) = 2; break;
+ case VT_I1: V_I1(&right) = 2; break;
+ case VT_UI1: V_UI1(&right) = 2; break;
+ case VT_UI2: V_UI2(&right) = 2; break;
+ case VT_UI4: V_UI4(&right) = 2; break;
+ case VT_I8: V_I8(&right) = 2; break;
+ case VT_UI8: V_UI8(&right) = 2; break;
+ case VT_INT: V_INT(&right) = 2; break;
+ case VT_UINT: V_UINT(&right) = 2; break;
+ default: break;
+ }
+
+ /* All extra flags produce errors */
+ if (ExtraFlags[i] == (VT_RESERVED|VT_ARRAY|VT_VECTOR|VT_BYREF) ||
+ ExtraFlags[i] == (VT_RESERVED|VT_ARRAY|VT_VECTOR) ||
+ ExtraFlags[i] == (VT_ARRAY|VT_RESERVED|VT_BYREF) ||
+ ExtraFlags[i] == (VT_ARRAY|VT_VECTOR|VT_BYREF) ||
+ ExtraFlags[i] == (VT_ARRAY|VT_RESERVED) ||
+ ExtraFlags[i] == (VT_ARRAY|VT_VECTOR) ||
+ ExtraFlags[i] == (VT_ARRAY|VT_BYREF) ||
+ ExtraFlags[i] == (VT_ARRAY))
+ expectedhres = DISP_E_TYPEMISMATCH;
+ else if (ExtraFlags[i])
+ expectedhres = DISP_E_BADVARTYPE;
+ /* Handling for all remaining errors and return types */
+ /* The following flags/types are invalid for left variant */
+ else if (!((leftvt <= VT_LPWSTR) && leftvt != (VARTYPE)15 &&
+ (leftvt < VT_VOID || leftvt > VT_LPWSTR)))
+ expectedhres = DISP_E_BADVARTYPE;
+ /* The following flags/types are invalid for right variant */
+ else if (!((rightvt <= VT_LPWSTR) && rightvt != (VARTYPE)15 &&
+ (rightvt < VT_VOID || rightvt > VT_LPWSTR)))
+ expectedhres = DISP_E_BADVARTYPE;
+ else if (rightvt == VT_EMPTY)
+ if (leftvt == VT_I1 || leftvt == VT_VARIANT ||
+ leftvt == VT_UI2 || leftvt == VT_UI2 ||
+ leftvt == VT_UI4 || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT)
+ expectedhres = DISP_E_BADVARTYPE;
+ else if (leftvt == VT_NULL)
+ resvt = VT_NULL;
+ else if (leftvt == VT_DECIMAL || leftvt == VT_BSTR)
+ expectedhres = DISP_E_DIVBYZERO;
+ else if (leftvt == VT_ERROR)
+ expectedhres = DISP_E_TYPEMISMATCH;
+ else
+ expectedhres = DISP_E_OVERFLOW;
+ else if (rightvt == VT_NULL && leftvt != VT_ERROR)
+ if (leftvt == VT_I1 || leftvt == VT_UI2 ||
+ leftvt == VT_UI2 || leftvt == VT_UI4 ||
+ leftvt == VT_VARIANT || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT)
+ expectedhres = DISP_E_BADVARTYPE;
+ else
+ resvt = VT_NULL;
+ else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
+ if (leftvt != rightvt &&(rightvt == VT_I1 ||
+ leftvt == VT_I1 || leftvt == VT_UI2 ||
+ leftvt == VT_UI4 || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT ||
+ rightvt == VT_UI2 || rightvt == VT_UI4 ||
+ rightvt == VT_UI8 || rightvt == VT_INT ||
+ rightvt == VT_UINT || rightvt == VT_VARIANT ||
+ leftvt == VT_VARIANT))
+ expectedhres = DISP_E_BADVARTYPE;
+ else
+ expectedhres = DISP_E_TYPEMISMATCH;
+ else if (leftvt == VT_CLSID || rightvt == VT_CLSID ||
+ leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
+ leftvt == VT_I1 || rightvt == VT_VARIANT ||
+ leftvt == VT_UI2 || leftvt == VT_UI4 ||
+ leftvt == VT_UI8 || leftvt == VT_INT ||
+ leftvt == VT_UINT)
+ expectedhres = DISP_E_BADVARTYPE;
+ else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
+ expectedhres = DISP_E_DIVBYZERO;
+ else if (leftvt == VT_I2 || rightvt == VT_I2 ||
+ leftvt == VT_I4 || rightvt == VT_I4 ||
+ leftvt == VT_R4 || rightvt == VT_R4 ||
+ leftvt == VT_R8 || rightvt == VT_R8 ||
+ leftvt == VT_CY || rightvt == VT_CY ||
+ leftvt == VT_DATE || rightvt == VT_DATE ||
+ leftvt == VT_BSTR || rightvt == VT_BSTR ||
+ leftvt == VT_BOOL || rightvt == VT_BOOL ||
+ leftvt == VT_UI1 || rightvt == VT_UI1 ||
+ leftvt == VT_I8 || rightvt == VT_I8 ||
+ leftvt == VT_NULL || leftvt == VT_DECIMAL ||
+ leftvt == VT_EMPTY)
+ {
+ if (rightvt == VT_UI2 || rightvt == VT_UI4 ||
+ rightvt == VT_UI8 || rightvt == VT_INT ||
+ rightvt == VT_UINT || rightvt == VT_I1)
+ expectedhres = DISP_E_BADVARTYPE;
+ else
+ {
+ if (leftvt == VT_NULL)
+ resvt = VT_NULL;
+ else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
+ resvt = VT_DECIMAL;
+ else if (leftvt == VT_R4 && (rightvt == VT_I2 ||
+ rightvt == VT_R4 || rightvt == VT_BOOL ||
+ rightvt == VT_UI1))
+ resvt = VT_R4;
+ else if (rightvt == VT_R4 && (leftvt == VT_I2 ||
+ leftvt == VT_BOOL || leftvt == VT_UI1 ||
+ leftvt == VT_EMPTY))
+ resvt = VT_R4;
+ else
+ resvt = VT_R8;
+ }
+ }
+
+ hres = pVarDiv(&left, &right, &result);
+
+ /* Check if the expected HRESULT and result variant type is correct */
+ ok(hres == expectedhres && resvt == V_VT(&result),
+ "VarDiv: %s|0x%X, %s|0x%X: expected vt %s hr 0x%lX, got vt %s hr 0x%lX\n",
+ vtstr(leftvt), ExtraFlags[i], vtstr(rightvt), ExtraFlags[i], vtstr(resvt),
+ expectedhres, vtstr(V_VT(&result)), hres);
+ }
+ }
+ }
+
+ /* Test return values for all the good cases */
+ VARDIV(EMPTY,0,NULL,0,NULL,0);
+ VARDIV(EMPTY,0,I2,2,R8,0.0);
+ VARDIV(EMPTY,0,I4,2,R8,0.0);
+ VARDIV(EMPTY,0,R4,2.0,R4,0.0);
+ VARDIV(EMPTY,0,R8,2.0,R8,0.0);
+ VARDIV(EMPTY,0,DATE,2.0,R8,0.0);
+ VARDIV(EMPTY,0,BSTR,num2_str,R8,0.0);
+ VARDIV(EMPTY,0,BOOL,2.0,R8,0.0);
+ VARDIV(EMPTY,0,UI1,2,R8,0.0);
+ VARDIV(EMPTY,0,I8,2,R8,0.0);
+ VARDIV(NULL,0,EMPTY,0,NULL,0);
+ VARDIV(NULL,0,NULL,0,NULL,0);
+ VARDIV(NULL,0,I2,2,NULL,0);
+ VARDIV(NULL,0,I4,2,NULL,0);
+ VARDIV(NULL,0,R4,2.0,NULL,0);
+ VARDIV(NULL,0,R8,2.0,NULL,0);
+ VARDIV(NULL,0,DATE,2,NULL,0);
+ VARDIV(NULL,0,BSTR,num2_str,NULL,0);
+ VARDIV(NULL,0,BOOL,VARIANT_TRUE,NULL,0);
+ VARDIV(NULL,0,UI1,2,NULL,0);
+ VARDIV(NULL,0,I8,2,NULL,0);
+ VARDIV(I2,2,NULL,0,NULL,0);
+ VARDIV(I2,1,I2,2,R8,0.5);
+ VARDIV(I2,1,I4,2,R8,0.5);
+ VARDIV(I2,1,R4,2,R4,0.5);
+ VARDIV(I2,1,R8,2.0,R8,0.5);
+ 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);
+ VARDIV(I2,1,I8,2,R8,0.5);
+ VARDIV(I4,1,NULL,0,NULL,0);
+ VARDIV(I4,1,I2,2,R8,0.5);
+ VARDIV(I4,1,I4,2,R8,0.5);
+ VARDIV(I4,1,R4,2.0,R8,0.5);
+ VARDIV(I4,1,R8,2.0,R8,0.5);
+ VARDIV(I4,1,DATE,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);
+ VARDIV(I4,1,I8,2.0,R8,0.5);
+ VARDIV(R4,1.0,NULL,0,NULL,0);
+ VARDIV(R4,1.0,I2,2,R4,0.5);
+ VARDIV(R4,1.0,I4,2,R8,0.5);
+ VARDIV(R4,1.0,R4,2.0,R4,0.5);
+ VARDIV(R4,1.0,R8,2.0,R8,0.5);
+ VARDIV(R4,1.0,DATE,2,R8,0.5);
+ VARDIV(R4,1.0,BSTR,num2_str,R8,0.5);
+ VARDIV(R4,1.0,BOOL,VARIANT_TRUE,R4,-1);
+ VARDIV(R4,1.0,UI1,2,R4,0.5);
+ VARDIV(R4,1.0,I8,2,R8,0.5);
+ VARDIV(R8,1.0,NULL,0,NULL,0);
+ VARDIV(R8,1.0,I2,2,R8,0.5);
+ VARDIV(R8,1.0,I4,2,R8,0.5);
+ VARDIV(R8,1.0,R4,2.0,R8,0.5);
+ VARDIV(R8,1.0,R8,2.0,R8,0.5);
+ VARDIV(R8,1.0,DATE,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);
+ VARDIV(R8,1.0,I8,2,R8,0.5);
+ VARDIV(DATE,1,NULL,0,NULL,0);
+ VARDIV(DATE,1,I2,2,R8,0.5);
+ VARDIV(DATE,1,I4,2,R8,0.5);
+ VARDIV(DATE,1,R4,2.0,R8,0.5);
+ VARDIV(DATE,1,R8,2.0,R8,0.5);
+ VARDIV(DATE,1,DATE,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);
+ VARDIV(DATE,1,I8,2,R8,0.5);
+ VARDIV(BSTR,num1_str,NULL,0,NULL,0);
+ VARDIV(BSTR,num1_str,I2,2,R8,0.5);
+ VARDIV(BSTR,num1_str,I4,2,R8,0.5);
+ VARDIV(BSTR,num1_str,R4,2.0,R8,0.5);
+ VARDIV(BSTR,num1_str,R8,2.0,R8,0.5);
+ VARDIV(BSTR,num1_str,DATE,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);
+ VARDIV(BSTR,num1_str,I8,2.0,R8,0.5);
+ VARDIV(BOOL,VARIANT_TRUE,NULL,0,NULL,0);
+ VARDIV(BOOL,VARIANT_TRUE,I2,1,R8,-1.0);
+ VARDIV(BOOL,VARIANT_FALSE,I2,1,R8,0.0);
+ VARDIV(BOOL,VARIANT_TRUE,I4,1,R8,-1.0);
+ VARDIV(BOOL,VARIANT_FALSE,I4,1,R8,0.0);
+ VARDIV(BOOL,VARIANT_TRUE,R4,1,R4,-1.0);
+ VARDIV(BOOL,VARIANT_FALSE,R4,1,R4,0.0);
+ VARDIV(BOOL,VARIANT_TRUE,R8,1.0,R8,-1.0);
+ VARDIV(BOOL,VARIANT_FALSE,R8,1.0,R8,0.0);
+ VARDIV(BOOL,VARIANT_FALSE,DATE,2,R8,0.0);
+ VARDIV(BOOL,VARIANT_FALSE,BSTR,num2_str,R8,0.0);
+ 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);
+ VARDIV(BOOL,VARIANT_TRUE,I8,1,R8,-1.0);
+ VARDIV(UI1,1,NULL,0,NULL,0);
+ VARDIV(UI1,1,I2,2,R8,0.5);
+ VARDIV(UI1,1,I4,2,R8,0.5);
+ VARDIV(UI1,1,R4,2.0,R4,0.5);
+ VARDIV(UI1,1,R8,2.0,R8,0.5);
+ VARDIV(UI1,1,DATE,2,R8,0.5);
+ 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);
+ VARDIV(UI1,1,I8,2,R8,0.5);
+ VARDIV(I8,1,NULL,0,NULL,0);
+ VARDIV(I8,1,I2,2,R8,0.5);
+ VARDIV(I8,1,I4,2,R8,0.5);
+ VARDIV(I8,1,R4,2.0,R8,0.5);
+ VARDIV(I8,1,R8,2.0,R8,0.5);
+ VARDIV(I8,1,DATE,2,R8,0.5);
+ VARDIV(I8,1,BSTR,num2_str,R8,0.5);
+ VARDIV(I8,1,BOOL,VARIANT_TRUE,R8,-1);
+ VARDIV(I8,1,UI1,2,R8,0.5);
+ VARDIV(I8,1,I8,2,R8,0.5);
+
+ /* Manually test some VT_CY, VT_DECIMAL variants */
+ V_VT(&cy) = VT_CY;
+ hres = VarCyFromI4(10000, &V_CY(&cy));
+ ok(hres == S_OK, "VarCyFromI4 failed!\n");
+ V_VT(&dec) = VT_DECIMAL;
+ hres = VarDecFromR8(2.0, &V_DECIMAL(&dec));
+ ok(hres == S_OK, "VarDecFromR4 failed!\n");
+ memset(&left, 0, sizeof(left));
+ memset(&right, 0, sizeof(right));
+ V_VT(&left) = VT_I4;
+ V_I4(&left) = 100;
+ V_VT(&right) = VT_UI1;
+ V_UI1(&right) = 2;
+
+ hres = VarDiv(&cy, &cy, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_R8,
+ "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
+ ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 1.0),
+ "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)1.0);
+
+ hres = VarDiv(&cy, &right, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_R8,
+ "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
+ ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 5000.0),
+ "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)5000.0);
+
+ hres = VarDiv(&left, &cy, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_R8,
+ "VARDIV: expected coerced type VT_R8, got %s!\n", vtstr(V_VT(&result)));
+ ok(hres == S_OK && EQ_DOUBLE(V_R8(&result), 0.01),
+ "VARDIV: CY value %f, expected %f\n", V_R8(&result), (double)0.01);
+
+ hres = VarDiv(&left, &dec, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
+ "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
+ hres = VarR8FromDec(&V_DECIMAL(&result), &r);
+ ok(hres == S_OK && EQ_DOUBLE(r, 50.0),
+ "VARDIV: DECIMAL value %f, expected %f\n", r, (double)50.0);
+
+ hres = VarDiv(&dec, &dec, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
+ "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
+ hres = VarR8FromDec(&V_DECIMAL(&result), &r);
+ ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
+ "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
+
+ hres = VarDiv(&dec, &right, &result);
+ ok(hres == S_OK && V_VT(&result) == VT_DECIMAL,
+ "VARDIV: expected coerced type VT_DECIMAL, got %s!\n", vtstr(V_VT(&result)));
+ hres = VarR8FromDec(&V_DECIMAL(&result), &r);
+ ok(hres == S_OK && EQ_DOUBLE(r, 1.0),
+ "VARDIV: DECIMAL value %f, expected %f\n", r, (double)1.0);
+
+ SysFreeString(true_str);
+ SysFreeString(false_str);
+ SysFreeString(num1_str);
+ SysFreeString(num2_str);
+}
+
START_TEST(vartest)
{
hOleaut32 = LoadLibraryA("oleaut32.dll");
@@ -6322,4 +6707,5 @@ START_TEST(vartest)
test_VarCat();
test_VarCmp();
test_VarAnd();
+ test_VarDiv();
}
--
1.4.0
More information about the wine-patches
mailing list