[PATCH v4 0/2] MR8635: oleaut32: Fix VarAnd string conversion length handling

[Maotong Zhang (＠xiaotong)]

Determine type (I4, I8) based on BSTR length, with I2 forcibly converted to I4.

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=56280

--
  v4: oleaut32: Fix VarAnd string conversion length handling
      oleaut32/tests: Add more BSTR test cases for VARAND

https://gitlab.winehq.org/wine/wine/-/merge_requests/8635

[PATCH v4 1/2] oleaut32/tests: Add more BSTR test cases for VARAND

[Maotong Zhang]

From: Maotong Zhang

---
 dlls/oleaut32/tests/vartest.c | 338 ++++++++++++++++++++++------------
 1 file changed, 216 insertions(+), 122 deletions(-)

diff --git a/dlls/oleaut32/tests/vartest.c b/dlls/oleaut32/tests/vartest.c
index eb1639e3990..41e9539917e 100644
--- a/dlls/oleaut32/tests/vartest.c
+++ b/dlls/oleaut32/tests/vartest.c
@@ -6783,18 +6783,25 @@ static void test_VarCat(void)

static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);

+ 
 #define VARAND(vt1,val1,vt2,val2,rvt,rval)               \
         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
         V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \
         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

-#define VARANDCY(vt1,val1,val2,rvt,rval)                 \
+#define VARANDRCY(vt1,val1,val2,rvt,rval)                 \
         V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1;   \
         V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \
         V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;     \
         test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

+#define VARANDLCY(val1,vt2,val2,rvt,rval)                  \
+        V_VT(&left) = VT_CY; V_CY(&left) .int64 = val1; \
+        V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2;      \
+        V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval;       \
+        test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )
+
 /* Skip any type that is not defined or produces an error for every case */
 #define SKIPTESTAND(a)                                \
         if (a == VT_ERROR || a == VT_VARIANT ||       \
@@ -6804,18 +6811,33 @@ static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);

static void test_VarAnd(void)
 {
-    static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
-    static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
     VARIANT left, right, exp, result;
-    BSTR false_str, true_str;
     VARTYPE i;
     HRESULT hres;
+    BSTR bstrtrue, bstrfalse, bstrmaxi2, bstrmini2, bstrmaxi4, bstrmini4, bstrmaxi8, bstrmini8, bstr1, bstr0;
+    BSTR bstrminus1, bstrminus42, bstrspaced1, bstrleading0, bstrfloat1p99, bstrfloatminus1p99, bstrsci1e2, bstrvbhex16;
+
+    bstrtrue = SysAllocString(L"#TRUE#");
+    bstrfalse = SysAllocString(L"#FALSE#");
+    bstrmaxi2 = SysAllocString(L"32767");
+    bstrmini2 = SysAllocString(L"-32768");
+    bstrmaxi4 = SysAllocString(L"2147483647");
+    bstrmini4 = SysAllocString(L"-2147483648");
+    bstrmaxi8 = SysAllocString(L"9223372036854775807");
+    bstrmini8 = SysAllocString(L"-9223372036854775807");
+    bstr1 = SysAllocString(L"1");
+    bstr0 = SysAllocString(L"0");
+    bstrminus1 = SysAllocString(L"-1");
+    bstrminus42 = SysAllocString(L"-42");
+    bstrspaced1 = SysAllocString(L" 1 ");
+    bstrleading0 = SysAllocString(L"0000123");
+    bstrfloat1p99 = SysAllocString(L"1.99");
+    bstrfloatminus1p99 = SysAllocString(L"-1.99");
+    bstrsci1e2 = SysAllocString(L"1e2");
+    bstrvbhex16 = SysAllocString(L"&H10");

CHECKPTR(VarAnd);

-    true_str = SysAllocString(szTrue);
-    false_str = SysAllocString(szFalse);
-
     /* Test all possible flag/vt combinations & the resulting vt type */
     for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++)
     {
@@ -6845,9 +6867,9 @@ static void test_VarAnd(void)
                 V_VT(&result) = VT_EMPTY;
                 resvt = VT_EMPTY;
                 if ((leftvt | ExtraFlags[i]) == VT_BSTR)
-                    V_BSTR(&left) = true_str;
+                    V_BSTR(&left) = bstrtrue;
                 if ((rightvt | ExtraFlags[i]) == VT_BSTR)
-                    V_BSTR(&right) = true_str;
+                    V_BSTR(&right) = bstrtrue;

/* Native VarAnd always returns an error when using extra
                  * flags or if the variant combination is I8 and INT.
@@ -6962,9 +6984,9 @@ static void test_VarAnd(void)
     VARAND(EMPTY,0,R8,0,I4,0);
     VARAND(EMPTY,0,R8,1,I4,0);
     VARAND(EMPTY,1,R8,1,I4,0);
-    VARAND(EMPTY,0,BSTR,false_str,I2,0);
-    VARAND(EMPTY,0,BSTR,true_str,I2,0);
-    VARANDCY(EMPTY,0,10000,I4,0);
+    VARAND(EMPTY,0,BSTR,bstrfalse,I2,0);
+    VARAND(EMPTY,0,BSTR,bstrtrue,I2,0);
+    VARANDRCY(EMPTY,0,10000,I4,0);

/* NULL OR 0 = NULL. NULL OR n = n */
     VARAND(NULL,0,NULL,0,NULL,0);
@@ -6998,10 +7020,10 @@ static void test_VarAnd(void)
     VARAND(NULL,0,R4,1,NULL,0);
     VARAND(NULL,0,R8,0,I4,0);
     VARAND(NULL,0,R8,1,NULL,0);
-    VARAND(NULL,0,BSTR,false_str,BOOL,0);
-    VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE);
-    VARANDCY(NULL,0,10000,NULL,0);
-    VARANDCY(NULL,0,0,I4,0);
+    VARAND(NULL,0,BSTR,bstrfalse,BOOL,0);
+    VARAND(NULL,0,BSTR,bstrtrue,NULL,VARIANT_FALSE);
+    VARANDRCY(NULL,0,10000,NULL,0);
+    VARANDRCY(NULL,0,0,I4,0);
     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE);
     VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE);
     VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE);
@@ -7049,13 +7071,13 @@ static void test_VarAnd(void)
     VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1);
     VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0);
     VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0);
-    VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE);
-    VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE);
-    VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE);
-    VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE);
-    VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1);
-    VARANDCY(BOOL,VARIANT_TRUE,0,I4,0);
-    VARANDCY(BOOL,VARIANT_FALSE,0,I4,0);
+    VARAND(BOOL,VARIANT_FALSE,BSTR,bstrfalse,BOOL,VARIANT_FALSE);
+    VARAND(BOOL,VARIANT_TRUE,BSTR,bstrfalse,BOOL,VARIANT_FALSE);
+    VARAND(BOOL,VARIANT_FALSE,BSTR,bstrtrue,BOOL,VARIANT_FALSE);
+    VARAND(BOOL,VARIANT_TRUE,BSTR,bstrtrue,BOOL,VARIANT_TRUE);
+    VARANDRCY(BOOL,VARIANT_TRUE,10000,I4,1);
+    VARANDRCY(BOOL,VARIANT_TRUE,0,I4,0);
+    VARANDRCY(BOOL,VARIANT_FALSE,0,I4,0);
     VARAND(I1,-1,I1,-1,I4,-1);
     VARAND(I1,-1,I1,0,I4,0);
     VARAND(I1,0,I1,0,I4,0);
@@ -7097,13 +7119,13 @@ static void test_VarAnd(void)
     VARAND(I1,-1,UINT,0xffffffff,I4,-1);
     VARAND(I1,-1,UINT,0,I4,0);
     VARAND(I1,0,UINT,0,I4,0);
-    VARAND(I1,0,BSTR,false_str,I4,0);
-    VARAND(I1,-1,BSTR,false_str,I4,0);
-    VARAND(I1,0,BSTR,true_str,I4,0);
-    VARAND(I1,-1,BSTR,true_str,I4,-1);
-    VARANDCY(I1,-1,10000,I4,1);
-    VARANDCY(I1,-1,0,I4,0);
-    VARANDCY(I1,0,0,I4,0);
+    VARAND(I1,0,BSTR,bstrfalse,I4,0);
+    VARAND(I1,-1,BSTR,bstrfalse,I4,0);
+    VARAND(I1,0,BSTR,bstrtrue,I4,0);
+    VARAND(I1,-1,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(I1,-1,10000,I4,1);
+    VARANDRCY(I1,-1,0,I4,0);
+    VARANDRCY(I1,0,0,I4,0);

VARAND(UI1,255,UI1,255,UI1,255);
     VARAND(UI1,255,UI1,0,UI1,0);
@@ -7143,13 +7165,13 @@ static void test_VarAnd(void)
     VARAND(UI1,255,UINT,0xffffffff,I4,255);
     VARAND(UI1,255,UINT,0,I4,0);
     VARAND(UI1,0,UINT,0,I4,0);
-    VARAND(UI1,0,BSTR,false_str,I2,0);
-    VARAND(UI1,255,BSTR,false_str,I2,0);
-    VARAND(UI1,0,BSTR,true_str,I2,0);
-    VARAND(UI1,255,BSTR,true_str,I2,255);
-    VARANDCY(UI1,255,10000,I4,1);
-    VARANDCY(UI1,255,0,I4,0);
-    VARANDCY(UI1,0,0,I4,0);
+    VARAND(UI1,0,BSTR,bstrfalse,I2,0);
+    VARAND(UI1,255,BSTR,bstrfalse,I2,0);
+    VARAND(UI1,0,BSTR,bstrtrue,I2,0);
+    VARAND(UI1,255,BSTR,bstrtrue,I2,255);
+    VARANDRCY(UI1,255,10000,I4,1);
+    VARANDRCY(UI1,255,0,I4,0);
+    VARANDRCY(UI1,0,0,I4,0);

VARAND(I2,-1,I2,-1,I2,-1);
     VARAND(I2,-1,I2,0,I2,0);
@@ -7186,13 +7208,14 @@ static void test_VarAnd(void)
     VARAND(I2,-1,UINT,0xffffffff,I4,-1);
     VARAND(I2,-1,UINT,0,I4,0);
     VARAND(I2,0,UINT,0,I4,0);
-    VARAND(I2,0,BSTR,false_str,I2,0);
-    VARAND(I2,-1,BSTR,false_str,I2,0);
-    VARAND(I2,0,BSTR,true_str,I2,0);
-    VARAND(I2,-1,BSTR,true_str,I2,-1);
-    VARANDCY(I2,-1,10000,I4,1);
-    VARANDCY(I2,-1,0,I4,0);
-    VARANDCY(I2,0,0,I4,0);
+    VARAND(I2,0,BSTR,bstrfalse,I2,0);
+    VARAND(I2,-1,BSTR,bstrfalse,I2,0);
+    VARAND(I2,0,BSTR,bstrtrue,I2,0);
+    VARAND(I2,-1,BSTR,bstrtrue,I2,-1);
+    VARANDRCY(I2,-1,10000,I4,1);
+    VARANDRCY(I2,-1,0,I4,0);
+    VARANDRCY(I2,0,0,I4,0);
+

VARAND(UI2,65535,UI2,65535,I4,65535);
     VARAND(UI2,65535,UI2,0,I4,0);
@@ -7226,13 +7249,13 @@ static void test_VarAnd(void)
     VARAND(UI2,65535,UINT,0xffffffff,I4,65535);
     VARAND(UI2,65535,UINT,0,I4,0);
     VARAND(UI2,0,UINT,0,I4,0);
-    VARAND(UI2,0,BSTR,false_str,I4,0);
-    VARAND(UI2,65535,BSTR,false_str,I4,0);
-    VARAND(UI2,0,BSTR,true_str,I4,0);
-    VARAND(UI2,65535,BSTR,true_str,I4,65535);
-    VARANDCY(UI2,65535,10000,I4,1);
-    VARANDCY(UI2,65535,0,I4,0);
-    VARANDCY(UI2,0,0,I4,0);
+    VARAND(UI2,0,BSTR,bstrfalse,I4,0);
+    VARAND(UI2,65535,BSTR,bstrfalse,I4,0);
+    VARAND(UI2,0,BSTR,bstrtrue,I4,0);
+    VARAND(UI2,65535,BSTR,bstrtrue,I4,65535);
+    VARANDRCY(UI2,65535,10000,I4,1);
+    VARANDRCY(UI2,65535,0,I4,0);
+    VARANDRCY(UI2,0,0,I4,0);

VARAND(I4,-1,I4,-1,I4,-1);
     VARAND(I4,-1,I4,0,I4,0);
@@ -7263,13 +7286,23 @@ static void test_VarAnd(void)
     VARAND(I4,-1,UINT,0xffffffff,I4,-1);
     VARAND(I4,-1,UINT,0,I4,0);
     VARAND(I4,0,UINT,0,I4,0);
-    VARAND(I4,0,BSTR,false_str,I4,0);
-    VARAND(I4,-1,BSTR,false_str,I4,0);
-    VARAND(I4,0,BSTR,true_str,I4,0);
-    VARAND(I4,-1,BSTR,true_str,I4,-1);
-    VARANDCY(I4,-1,10000,I4,1);
-    VARANDCY(I4,-1,0,I4,0);
-    VARANDCY(I4,0,0,I4,0);
+    VARAND(I4,0,BSTR,bstrfalse,I4,0);
+    VARAND(I4,-1,BSTR,bstrfalse,I4,0);
+    VARAND(I4,0,BSTR,bstrtrue,I4,0);
+    VARAND(I4,-1,BSTR,bstrtrue,I4,-1);
+    VARAND(I4, 1, BSTR, bstrmaxi4, I4, (1 & 2147483647));
+    VARAND(I4, 1, BSTR, bstrmini4, I4, (-2147483648 & 1));
+    VARAND(I4, 1, BSTR, bstrleading0, I4, (1 &123));
+    VARAND(I4, 1, BSTR, bstrspaced1, I4, (1 & 1));
+    VARAND(I4, 1, BSTR, bstrminus1, I4, (1 & -1));
+    VARAND(I4, 1, BSTR, bstr0, I4, (1 & 0));
+    VARAND(I4, 1, BSTR, bstrminus42, I4, ( 1 & -42));
+    VARAND(I4, 1, BSTR, bstrsci1e2, I4, (1 & 100));
+    VARAND(I4, 1, BSTR, bstrfloat1p99, I4, 0);
+    VARAND(I4, 1, BSTR, bstrvbhex16, I4, (1 & 0x10));
+    VARANDRCY(I4,-1,10000,I4,1);
+    VARANDRCY(I4,-1,0,I4,0);
+    VARANDRCY(I4,0,0,I4,0);

VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1);
     VARAND(UI4,0xffffffff,UI4,0,I4,0);
@@ -7296,13 +7329,13 @@ static void test_VarAnd(void)
     VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1);
     VARAND(UI4,0xffffffff,UINT,0,I4,0);
     VARAND(UI4,0,UINT,0,I4,0);
-    VARAND(UI4,0,BSTR,false_str,I4,0);
-    VARAND(UI4,0xffffffff,BSTR,false_str,I4,0);
-    VARAND(UI4,0,BSTR,true_str,I4,0);
-    VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1);
-    VARANDCY(UI4,0xffffffff,10000,I4,1);
-    VARANDCY(UI4,0xffffffff,0,I4,0);
-    VARANDCY(UI4,0,0,I4,0);
+    VARAND(UI4,0,BSTR,bstrfalse,I4,0);
+    VARAND(UI4,0xffffffff,BSTR,bstrfalse,I4,0);
+    VARAND(UI4,0,BSTR,bstrtrue,I4,0);
+    VARAND(UI4,0xffffffff,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(UI4,0xffffffff,10000,I4,1);
+    VARANDRCY(UI4,0xffffffff,0,I4,0);
+    VARANDRCY(UI4,0,0,I4,0);

VARAND(R4,-1,R4,-1,I4,-1);
     VARAND(R4,-1,R4,0,I4,0);
@@ -7327,13 +7360,13 @@ static void test_VarAnd(void)
     VARAND(R4,-1,UINT,0xffffffff,I4,-1);
     VARAND(R4,-1,UINT,0,I4,0);
     VARAND(R4,0,UINT,0,I4,0);
-    VARAND(R4,0,BSTR,false_str,I4,0);
-    VARAND(R4,-1,BSTR,false_str,I4,0);
-    VARAND(R4,0,BSTR,true_str,I4,0);
-    VARAND(R4,-1,BSTR,true_str,I4,-1);
-    VARANDCY(R4,-1,10000,I4,1);
-    VARANDCY(R4,-1,0,I4,0);
-    VARANDCY(R4,0,0,I4,0);
+    VARAND(R4,0,BSTR,bstrfalse,I4,0);
+    VARAND(R4,-1,BSTR,bstrfalse,I4,0);
+    VARAND(R4,0,BSTR,bstrtrue,I4,0);
+    VARAND(R4,-1,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(R4,-1,10000,I4,1);
+    VARANDRCY(R4,-1,0,I4,0);
+    VARANDRCY(R4,0,0,I4,0);

VARAND(R8,-1,R8,-1,I4,-1);
     VARAND(R8,-1,R8,0,I4,0);
@@ -7355,13 +7388,13 @@ static void test_VarAnd(void)
     VARAND(R8,-1,UINT,0xffffffff,I4,-1);
     VARAND(R8,-1,UINT,0,I4,0);
     VARAND(R8,0,UINT,0,I4,0);
-    VARAND(R8,0,BSTR,false_str,I4,0);
-    VARAND(R8,-1,BSTR,false_str,I4,0);
-    VARAND(R8,0,BSTR,true_str,I4,0);
-    VARAND(R8,-1,BSTR,true_str,I4,-1);
-    VARANDCY(R8,-1,10000,I4,1);
-    VARANDCY(R8,-1,0,I4,0);
-    VARANDCY(R8,0,0,I4,0);
+    VARAND(R8,0,BSTR,bstrfalse,I4,0);
+    VARAND(R8,-1,BSTR,bstrfalse,I4,0);
+    VARAND(R8,0,BSTR,bstrtrue,I4,0);
+    VARAND(R8,-1,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(R8,-1,10000,I4,1);
+    VARANDRCY(R8,-1,0,I4,0);
+    VARANDRCY(R8,0,0,I4,0);

VARAND(DATE,-1,DATE,-1,I4,-1);
     VARAND(DATE,-1,DATE,0,I4,0);
@@ -7380,13 +7413,13 @@ static void test_VarAnd(void)
     VARAND(DATE,-1,UINT,0xffffffff,I4,-1);
     VARAND(DATE,-1,UINT,0,I4,0);
     VARAND(DATE,0,UINT,0,I4,0);
-    VARAND(DATE,0,BSTR,false_str,I4,0);
-    VARAND(DATE,-1,BSTR,false_str,I4,0);
-    VARAND(DATE,0,BSTR,true_str,I4,0);
-    VARAND(DATE,-1,BSTR,true_str,I4,-1);
-    VARANDCY(DATE,-1,10000,I4,1);
-    VARANDCY(DATE,-1,0,I4,0);
-    VARANDCY(DATE,0,0,I4,0);
+    VARAND(DATE,0,BSTR,bstrfalse,I4,0);
+    VARAND(DATE,-1,BSTR,bstrfalse,I4,0);
+    VARAND(DATE,0,BSTR,bstrtrue,I4,0);
+    VARAND(DATE,-1,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(DATE,-1,10000,I4,1);
+    VARANDRCY(DATE,-1,0,I4,0);
+    VARANDRCY(DATE,0,0,I4,0);

if (has_i8)
     {
@@ -7397,13 +7430,15 @@ static void test_VarAnd(void)
         VARAND(I8,0,UI8,0,I8,0);
         VARAND(I8,-1,UINT,0,I8,0);
         VARAND(I8,0,UINT,0,I8,0);
-        VARAND(I8,0,BSTR,false_str,I8,0);
-        VARAND(I8,-1,BSTR,false_str,I8,0);
-        VARAND(I8,0,BSTR,true_str,I8,0);
-        VARAND(I8,-1,BSTR,true_str,I8,-1);
-        VARANDCY(I8,-1,10000,I8,1);
-        VARANDCY(I8,-1,0,I8,0);
-        VARANDCY(I8,0,0,I8,0);
+        VARAND(I8,0,BSTR,bstrfalse,I8,0);
+        VARAND(I8,-1,BSTR,bstrfalse,I8,0);
+        VARAND(I8,0,BSTR,bstrtrue,I8,0);
+        VARAND(I8,-1,BSTR,bstrtrue,I8,-1);
+        VARAND(I8, 1, BSTR, bstrmaxi8, I8, 1);
+        VARAND(I8, 1, BSTR, bstrmini8, I8, 1);
+        VARANDRCY(I8,-1,10000,I8,1);
+        VARANDRCY(I8,-1,0,I8,0);
+        VARANDRCY(I8,0,0,I8,0);

VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff);
         VARAND(UI8,0xffff,UI8,0,I4,0);
@@ -7414,13 +7449,13 @@ static void test_VarAnd(void)
         VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff);
         VARAND(UI8,0xffff,UINT,0,I4,0);
         VARAND(UI8,0,UINT,0,I4,0);
-        VARAND(UI8,0,BSTR,false_str,I4,0);
-        VARAND(UI8,0xffff,BSTR,false_str,I4,0);
-        VARAND(UI8,0,BSTR,true_str,I4,0);
-        VARAND(UI8,0xffff,BSTR,true_str,I4,65535);
-        VARANDCY(UI8,0xffff,10000,I4,1);
-        VARANDCY(UI8,0xffff,0,I4,0);
-        VARANDCY(UI8,0,0,I4,0);
+        VARAND(UI8,0,BSTR,bstrfalse,I4,0);
+        VARAND(UI8,0xffff,BSTR,bstrfalse,I4,0);
+        VARAND(UI8,0,BSTR,bstrtrue,I4,0);
+        VARAND(UI8,0xffff,BSTR,bstrtrue,I4,65535);
+        VARANDRCY(UI8,0xffff,10000,I4,1);
+        VARANDRCY(UI8,0xffff,0,I4,0);
+        VARANDRCY(UI8,0,0,I4,0);
     }

VARAND(INT,-1,INT,-1,I4,-1);
@@ -7429,33 +7464,92 @@ static void test_VarAnd(void)
     VARAND(INT,-1,UINT,0xffff,I4,65535);
     VARAND(INT,-1,UINT,0,I4,0);
     VARAND(INT,0,UINT,0,I4,0);
-    VARAND(INT,0,BSTR,false_str,I4,0);
-    VARAND(INT,-1,BSTR,false_str,I4,0);
-    VARAND(INT,0,BSTR,true_str,I4,0);
-    VARAND(INT,-1,BSTR,true_str,I4,-1);
-    VARANDCY(INT,-1,10000,I4,1);
-    VARANDCY(INT,-1,0,I4,0);
-    VARANDCY(INT,0,0,I4,0);
+    VARAND(INT,0,BSTR,bstrfalse,I4,0);
+    VARAND(INT,-1,BSTR,bstrfalse,I4,0);
+    VARAND(INT,0,BSTR,bstrtrue,I4,0);
+    VARAND(INT,-1,BSTR,bstrtrue,I4,-1);
+    VARANDRCY(INT,-1,10000,I4,1);
+    VARANDRCY(INT,-1,0,I4,0);
+    VARANDRCY(INT,0,0,I4,0);

VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff);
     VARAND(UINT,0xffff,UINT,0,I4,0);
     VARAND(UINT,0,UINT,0,I4,0);
-    VARAND(UINT,0,BSTR,false_str,I4,0);
-    VARAND(UINT,0xffff,BSTR, false_str,I4,0);
-    VARAND(UINT,0,BSTR,true_str,I4,0);
-    VARAND(UINT,0xffff,BSTR,true_str,I4,65535);
-    VARANDCY(UINT,0xffff,10000,I4,1);
-    VARANDCY(UINT,0xffff,0,I4,0);
-    VARANDCY(UINT,0,0,I4,0);
-
-    VARAND(BSTR,false_str,BSTR,false_str,BOOL,0);
-    VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE);
-    VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE);
-    VARANDCY(BSTR,true_str,10000,I4,1);
-    VARANDCY(BSTR,false_str,10000,I4,0);
+    VARAND(UINT,0,BSTR,bstrfalse,I4,0);
+    VARAND(UINT,0xffff,BSTR, bstrfalse,I4,0);
+    VARAND(UINT,0,BSTR,bstrtrue,I4,0);
+    VARAND(UINT,0xffff,BSTR,bstrtrue,I4,65535);
+    VARANDRCY(UINT,0xffff,10000,I4,1);
+    VARANDRCY(UINT,0xffff,0,I4,0);
+    VARANDRCY(UINT,0,0,I4,0);
+
+    VARAND(BSTR,bstrfalse,BSTR,bstrfalse,BOOL,0);
+    VARAND(BSTR,bstrtrue,BSTR,bstrfalse,BOOL,VARIANT_FALSE);
+    VARAND(BSTR,bstrtrue,BSTR,bstrtrue,BOOL,VARIANT_TRUE);
+    VARAND(BSTR, bstrmaxi4, I4, 1, I4, (2147483647 & 1));
+    VARAND(BSTR, bstrmini4, I4, 1, I4, (-2147483648 & 1));

-    SysFreeString(true_str);
-    SysFreeString(false_str);
+    if (has_i8)
+    {
+        VARAND(BSTR, bstrmaxi8, I8, 1, I8, 1);
+        VARAND(BSTR, bstrmini8, I8, 1, I8, 1);
+    }
+
+    VARAND(BSTR, bstrleading0, I4, 1, I4, (123 & 1));
+    VARAND(BSTR, bstrspaced1, I4, 1, I4, (1 & 1));
+    VARAND(BSTR, bstrminus1, I4, 1, I4, (-1 & 1));
+    VARAND(BSTR, bstr0, I4, 1, I4, (0 & 1));
+    VARAND(BSTR, bstrminus42, I4, 1, I4, (-42 & 1));
+    VARAND(BSTR, bstrsci1e2, I4, 1, I4, (100 & 1));
+    VARAND(BSTR, bstrfloat1p99, I4, 1, I4, 0);
+    VARAND(BSTR, bstrvbhex16, I4, 1, I4, (0x10 & 1));
+
+    VARANDRCY(BSTR, bstrtrue, 10000, I4, 1);
+    VARANDRCY(BSTR, bstrfalse, 10000, I4, 0);
+    VARANDRCY(BSTR, bstr1, 10000, I4, 1);
+    VARANDRCY(BSTR, bstr0, 10000, I4, 0);
+    VARANDRCY(BSTR, bstrminus1, 10000, I4, 1);
+    VARANDRCY(BSTR, bstrmaxi2, 10000, I4, 1);
+    VARANDRCY(BSTR, bstrmaxi4, 10000, I4, 1);
+    VARANDRCY(BSTR, bstrmini2, 10000, I4, 0);
+    VARANDRCY(BSTR, bstrspaced1, 10000, I4, 1);
+    VARANDRCY(BSTR, bstrfloat1p99, 10000, I4, 0);
+    VARANDRCY(BSTR, bstrfloatminus1p99, 10000, I4, 0);
+    VARANDRCY(BSTR, bstrsci1e2, 10000, I4, 0);
+    VARANDRCY(BSTR, bstrmaxi2, 0, I4, 0);
+
+    VARANDLCY(10000, BSTR, bstrtrue, I4, 1);
+    VARANDLCY(10000, BSTR, bstrfalse, I4, 0);
+    VARANDLCY(10000, BSTR, bstr1, I4, 1);
+    VARANDLCY(10000, BSTR, bstr0, I4, 0);
+    VARANDLCY(10000, BSTR, bstrminus1, I4, 1);
+    VARANDLCY(10000, BSTR, bstrmaxi2, I4, 1);
+    VARANDLCY(10000, BSTR, bstrmaxi4, I4, 1);
+    VARANDLCY(10000, BSTR, bstrmini2, I4, 0);
+    VARANDLCY(10000, BSTR, bstrspaced1, I4, 1);
+    VARANDLCY(10000, BSTR, bstrfloat1p99, I4, 0);
+    VARANDLCY(10000, BSTR, bstrfloatminus1p99, I4, 0);
+    VARANDLCY(10000, BSTR, bstrsci1e2, I4, 0);
+    VARANDLCY(0, BSTR,bstrmaxi2, I4, 0);
+
+    SysFreeString(bstrtrue);
+    SysFreeString(bstrfalse);
+    SysFreeString(bstrmaxi2);
+    SysFreeString(bstrmini2);
+    SysFreeString(bstrmaxi4);
+    SysFreeString(bstrmini4);
+    SysFreeString(bstrmaxi8);
+    SysFreeString(bstrmini8);
+    SysFreeString(bstr1);
+    SysFreeString(bstr0);
+    SysFreeString(bstrminus1);
+    SysFreeString(bstrminus42);
+    SysFreeString(bstrspaced1);
+    SysFreeString(bstrleading0);
+    SysFreeString(bstrfloat1p99);
+    SysFreeString(bstrfloatminus1p99);
+    SysFreeString(bstrsci1e2);
+    SysFreeString(bstrvbhex16);
 }

static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )

[PATCH v4 2/2] oleaut32: Fix VarAnd string conversion length handling

[Maotong Zhang]

From: Maotong Zhang

Determine type (I4, I8) based on BSTR length, with I2 forcibly converted to I4.

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=56280
---
 dlls/oleaut32/variant.c | 97 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 82 insertions(+), 15 deletions(-)

diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c
index fbe035a5576..ee23ab02a29 100644
--- a/dlls/oleaut32/variant.c
+++ b/dlls/oleaut32/variant.c
@@ -3106,33 +3106,100 @@ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
         V_VT(&varLeft) = VT_I4; /* Don't overflow */
     else
     {
-        DOUBLE d;
+        if (V_VT(&varLeft) == VT_BSTR)
+        {
+            LONGLONG val64;
+            HRESULT tmpres = VarI8FromStr(V_BSTR(&varLeft), LOCALE_USER_DEFAULT, 0, &val64);
+            if (SUCCEEDED(tmpres))
+            {
+                VARIANT tmpvar;
+                VariantInit(&tmpvar);

-        if (V_VT(&varLeft) == VT_BSTR &&
-            FAILED(VarR8FromStr(V_BSTR(&varLeft),
-            LOCALE_USER_DEFAULT, 0, &d)))
-            hres = VariantChangeType(&varLeft,&varLeft,
-            VARIANT_LOCALBOOL, VT_BOOL);
+                if (val64 >= LONG_MIN && val64 <= LONG_MAX)
+                {
+                    V_VT(&tmpvar) = VT_I4;
+                    V_I4(&tmpvar) = (LONG)val64;
+                    resvt = VT_I4;
+                }
+                else
+                {
+                    V_VT(&tmpvar) = VT_I8;
+                    V_I8(&tmpvar) = val64;
+                    resvt = VT_I8;
+                }
+
+                VariantClear(&varLeft);
+                hres = VariantCopy(&varLeft, &tmpvar);
+                VariantClear(&tmpvar);
+            }
+            else
+            {
+                double d;
+                if (FAILED(VarR8FromStr(V_BSTR(&varLeft), LOCALE_USER_DEFAULT, 0, &d)))
+                    hres = VariantChangeType(&varLeft, &varLeft, VARIANT_LOCALBOOL, VT_BOOL);
+            }
+            if (FAILED(hres)) goto VarAnd_Exit;
+        }
         if (SUCCEEDED(hres) && V_VT(&varLeft) != resvt)
-            hres = VariantChangeType(&varLeft,&varLeft,0,resvt);
+            hres = VariantChangeType(&varLeft, &varLeft, 0, resvt);
         if (FAILED(hres)) goto VarAnd_Exit;
     }
-
     if (resvt == VT_I4 && V_VT(&varRight) == VT_UI4)
         V_VT(&varRight) = VT_I4; /* Don't overflow */
     else
     {
-        DOUBLE d;
+        if (V_VT(&varRight) == VT_BSTR)
+        {
+            LONGLONG val64;
+            HRESULT tmpres = VarI8FromStr(V_BSTR(&varRight), LOCALE_USER_DEFAULT, 0, &val64);
+            if (SUCCEEDED(tmpres))
+            {
+                VARIANT tmpvar;
+                VariantInit(&tmpvar);

-        if (V_VT(&varRight) == VT_BSTR &&
-            FAILED(VarR8FromStr(V_BSTR(&varRight),
-            LOCALE_USER_DEFAULT, 0, &d)))
-            hres = VariantChangeType(&varRight, &varRight,
-                VARIANT_LOCALBOOL, VT_BOOL);
+                if (val64 >= LONG_MIN && val64 <= LONG_MAX)
+                {
+                    V_VT(&tmpvar) = VT_I4;
+                    V_I4(&tmpvar) = (LONG)val64;
+                    resvt = VT_I4;
+                }
+                else
+                {
+                    V_VT(&tmpvar) = VT_I8;
+                    V_I8(&tmpvar) = val64;
+                    resvt = VT_I8;
+                }
+
+                VariantClear(&varRight);
+                hres = VariantCopy(&varRight, &tmpvar);
+                VariantClear(&tmpvar);
+            }
+            else
+            {
+                double d;
+                if (FAILED(VarR8FromStr(V_BSTR(&varRight), LOCALE_USER_DEFAULT, 0, &d)))
+                    hres = VariantChangeType(&varRight, &varRight, VARIANT_LOCALBOOL, VT_BOOL);
+            }
+            if (FAILED(hres)) goto VarAnd_Exit;
+        }
         if (SUCCEEDED(hres) && V_VT(&varRight) != resvt)
-            hres = VariantChangeType(&varRight, &varRight, 0, resvt);
+              hres = VariantChangeType(&varRight, &varRight, 0, resvt);
         if (FAILED(hres)) goto VarAnd_Exit;
     }
+    if (SUCCEEDED(hres))
+    {
+        if (V_VT(&varLeft) != resvt)
+        {
+            hres = VariantChangeType(&varLeft, &varLeft, 0, resvt);
+            if (FAILED(hres)) goto VarAnd_Exit;
+        }
+
+        if (V_VT(&varRight) != resvt)
+        {
+            hres = VariantChangeType(&varRight, &varRight, 0, resvt);
+            if (FAILED(hres)) goto VarAnd_Exit;
+        }
+    }

V_VT(result) = resvt;
     switch(resvt)

[Maotong Zhang (＠xiaotong)]

v2: Add more test cases and fix the Windows VT_I4 test issue.