[PATCH v2 0/6] MR10196: Implement VariantCompare.

[eric pouech (＠epo)]

--
  v2: propsys: Implement VariantCompare().
      propsys/tests: Add tests for VariantCompare().
      propsys: Add stub for VariantCompare().
      propsys: Add proper support for VT_R4 in PropVariantCompareEx?
      propsys/tests: Add some tests in PropVariantCompareEx.
      include: Add definition for VariantCompare in propvarutil.h
 
https://gitlab.winehq.org/wine/wine/-/merge_requests/10196

[PATCH v2 1/6] include: Add definition for VariantCompare in propvarutil.h

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Signed-off-by: Eric Pouech <[e-mail]>
---
 include/propvarutil.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/propvarutil.h b/include/propvarutil.h
index 003a4f761a8..dae95152b08 100644
--- a/include/propvarutil.h
+++ b/include/propvarutil.h
@@ -118,6 +118,7 @@ PSSTDAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch);
 PSSTDAPI_(PCWSTR) PropVariantToStringWithDefault(REFPROPVARIANT propvarIn, LPCWSTR pszDefault);
 PSSTDAPI_(PCWSTR) VariantToStringWithDefault(const VARIANT *pvar, LPCWSTR pszDefault);
 PSSTDAPI VariantToString(REFVARIANT var, PWSTR ret, UINT cch);
+PSSTDAPI_(INT) VariantCompare(REFVARIANT var1, REFVARIANT var2);
 
 PSSTDAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret);
 
-- 
GitLab


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

[PATCH v2 2/6] propsys/tests: Add some tests in PropVariantCompareEx.

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Add a couple of missing initializations.

Signed-off-by: Eric Pouech <[e-mail]>
---
 dlls/propsys/tests/propsys.c | 37 +++++++++++++++++++++++++++++++++++-
 1 file changed, 36 insertions(+), 1 deletion(-)

diff --git a/dlls/propsys/tests/propsys.c b/dlls/propsys/tests/propsys.c
index 17c9e87d7ef..a60dcb4b45a 100644
--- a/dlls/propsys/tests/propsys.c
+++ b/dlls/propsys/tests/propsys.c
@@ -712,7 +712,7 @@ static void test_PropVariantToStringAlloc(void)
 static void test_PropVariantCompareEx(void)
 {
     PROPVARIANT empty, null, emptyarray, i2_0, i2_2, i4_large, i4_largeneg, i4_2, str_2, str_02, str_b;
-    PROPVARIANT clsid_null, clsid, clsid2, r4_0, r4_2, r8_0, r8_2;
+    PROPVARIANT clsid_null, clsid, clsid2, r4_0, r4_2, r4_21, r8_0, r8_2;
     PROPVARIANT ui4, ui4_large;
     PROPVARIANT var1, var2;
     INT res;
@@ -732,7 +732,18 @@ static void test_PropVariantCompareEx(void)
     PropVariantInit(&i4_largeneg);
     PropVariantInit(&i4_2);
     PropVariantInit(&str_2);
+    PropVariantInit(&str_02);
     PropVariantInit(&str_b);
+    PropVariantInit(&clsid_null);
+    PropVariantInit(&clsid);
+    PropVariantInit(&clsid2);
+    PropVariantInit(&r4_0);
+    PropVariantInit(&r4_2);
+    PropVariantInit(&r4_21);
+    PropVariantInit(&r8_0);
+    PropVariantInit(&r8_2);
+    PropVariantInit(&ui4_large);
+    PropVariantInit(&ui4);
 
     empty.vt = VT_EMPTY;
     null.vt = VT_NULL;
@@ -775,6 +786,8 @@ static void test_PropVariantCompareEx(void)
     r4_0.fltVal = 0.0f;
     r4_2.vt = VT_R4;
     r4_2.fltVal = 2.0f;
+    r4_21.vt = VT_R4;
+    r4_21.fltVal = 2.1f;
     r8_0.vt = VT_R8;
     r8_0.dblVal = 0.0;
     r8_2.vt = VT_R8;
@@ -972,6 +985,28 @@ static void test_PropVariantCompareEx(void)
     res = PropVariantCompareEx(&var1, &var2, 0, 0);
     ok(res == 0, "res=%i\n", res);
 
+    res = PropVariantCompareEx(&r4_2, &i4_largeneg, 0, 0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = PropVariantCompareEx(&r4_2, &i4_large, 0, 0);
+    ok(res == -1, "res=%i\n", res);
+
+    res = PropVariantCompareEx(&i4_large, &r4_2, 0, 0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = PropVariantCompareEx(&i4_largeneg, &r4_2, 0, 0);
+    ok(res == -1, "res=%i\n", res);
+
+    res = PropVariantCompareEx(&r4_21, &i2_2, 0, 0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = PropVariantCompareEx(&i2_2, &r4_21, 0, 0);
+    todo_wine
+    ok(res == 0, "res=%i\n", res);
+
     SysFreeString(str_2.bstrVal);
     SysFreeString(str_02.bstrVal);
     SysFreeString(str_b.bstrVal);
-- 
GitLab


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

[PATCH v2 3/6] propsys: Add proper support for VT_R4 in PropVariantCompareEx?

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Signed-off-by: Eric Pouech <[e-mail]>
---
 dlls/propsys/propvar.c       | 19 +++++++++++++++++++
 dlls/propsys/tests/propsys.c |  5 -----
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/dlls/propsys/propvar.c b/dlls/propsys/propvar.c
index 7a1ee5fd876..821c43d39ed 100644
--- a/dlls/propsys/propvar.c
+++ b/dlls/propsys/propvar.c
@@ -146,6 +146,12 @@ static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
         src_signed = *res < 0;
         break;
     }
+    case VT_R4:
+    {
+        src_signed = TRUE;
+        *res = pv->fltVal;
+        break;
+    }
     case VT_R8:
     {
         src_signed = TRUE;
@@ -717,6 +723,19 @@ HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT p
         }
         return hr;
     }
+
+    case VT_R4:
+    {
+        double res;
+        hr = PropVariantToDouble(propvarSrc, &res);
+        if (SUCCEEDED(hr))
+        {
+            ppropvarDest->vt = VT_R4;
+            ppropvarDest->fltVal = (float)res;
+        }
+        return hr;
+    }
+
     case VT_R8:
     {
         double res;
diff --git a/dlls/propsys/tests/propsys.c b/dlls/propsys/tests/propsys.c
index a60dcb4b45a..d6faee19add 100644
--- a/dlls/propsys/tests/propsys.c
+++ b/dlls/propsys/tests/propsys.c
@@ -896,7 +896,6 @@ static void test_PropVariantCompareEx(void)
 
     /* VT_R4/VT_R8 */
     res = PropVariantCompareEx(&r4_0, &r8_0, 0, 0);
-    todo_wine
     ok(res == 0, "res=%i\n", res);
 
     res = PropVariantCompareEx(&r4_0, &r4_0, 0, 0);
@@ -986,25 +985,21 @@ static void test_PropVariantCompareEx(void)
     ok(res == 0, "res=%i\n", res);
 
     res = PropVariantCompareEx(&r4_2, &i4_largeneg, 0, 0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = PropVariantCompareEx(&r4_2, &i4_large, 0, 0);
     ok(res == -1, "res=%i\n", res);
 
     res = PropVariantCompareEx(&i4_large, &r4_2, 0, 0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = PropVariantCompareEx(&i4_largeneg, &r4_2, 0, 0);
     ok(res == -1, "res=%i\n", res);
 
     res = PropVariantCompareEx(&r4_21, &i2_2, 0, 0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = PropVariantCompareEx(&i2_2, &r4_21, 0, 0);
-    todo_wine
     ok(res == 0, "res=%i\n", res);
 
     SysFreeString(str_2.bstrVal);
-- 
GitLab


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

[PATCH v2 4/6] propsys: Add stub for VariantCompare().

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Signed-off-by: Eric Pouech <[e-mail]>
---
 dlls/propsys/propsys.spec | 2 +-
 dlls/propsys/propvar.c    | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/dlls/propsys/propsys.spec b/dlls/propsys/propsys.spec
index 28245452f6f..670f7282041 100644
--- a/dlls/propsys/propsys.spec
+++ b/dlls/propsys/propsys.spec
@@ -153,7 +153,7 @@
 @ stdcall PropVariantToVariant(ptr ptr)
 @ stub StgDeserializePropVariant
 @ stub StgSerializePropVariant
-@ stub VariantCompare
+@ stdcall VariantCompare(ptr ptr)
 @ stub VariantGetBooleanElem
 @ stub VariantGetDoubleElem
 @ stub VariantGetElementCount
diff --git a/dlls/propsys/propvar.c b/dlls/propsys/propvar.c
index 821c43d39ed..b5f4099f2c6 100644
--- a/dlls/propsys/propvar.c
+++ b/dlls/propsys/propvar.c
@@ -1183,6 +1183,12 @@ INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2
     return res;
 }
 
+INT WINAPI VariantCompare(REFVARIANT refvar1, REFVARIANT refvar2)
+{
+    FIXME("%s %s: stub!\n", debugstr_variant(refvar1), debugstr_variant(refvar2));
+    return 0;
+}
+
 HRESULT WINAPI PropVariantToVariant(const PROPVARIANT *propvar, VARIANT *var)
 {
     HRESULT hr = S_OK;
-- 
GitLab


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

[PATCH v2 5/6] propsys/tests: Add tests for VariantCompare().

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Signed-off-by: Eric Pouech <[e-mail]>
---
 dlls/propsys/tests/propsys.c | 231 +++++++++++++++++++++++++++++++++++
 1 file changed, 231 insertions(+)

diff --git a/dlls/propsys/tests/propsys.c b/dlls/propsys/tests/propsys.c
index d6faee19add..82fdb59c5e9 100644
--- a/dlls/propsys/tests/propsys.c
+++ b/dlls/propsys/tests/propsys.c
@@ -1007,6 +1007,236 @@ static void test_PropVariantCompareEx(void)
     SysFreeString(str_b.bstrVal);
 }
 
+static void test_VariantCompare(void)
+{
+    VARIANT empty, null, emptyarray, i2_0, i2_2, i4_large, i4_largeneg, i4_2, str_2, str_02, str_b;
+    VARIANT r4_0, r4_2, r4_21, r8_0, r8_2;
+    VARIANT ui4, ui4_large;
+    INT res;
+    static const WCHAR str_2W[] = {'2', 0};
+    static const WCHAR str_02W[] = {'0', '2', 0};
+    static const WCHAR str_bW[] = {'b', 0};
+    SAFEARRAY emptysafearray;
+
+    VariantInit(&empty);
+    VariantInit(&null);
+    VariantInit(&emptyarray);
+    VariantInit(&i2_0);
+    VariantInit(&i2_2);
+    VariantInit(&i4_large);
+    VariantInit(&i4_largeneg);
+    VariantInit(&i4_2);
+    VariantInit(&ui4);
+    VariantInit(&ui4_large);
+    VariantInit(&str_2);
+    VariantInit(&str_02);
+    VariantInit(&str_b);
+    VariantInit(&r4_0);
+    VariantInit(&r4_2);
+    VariantInit(&r4_2);
+    VariantInit(&r8_0);
+    VariantInit(&r8_2);
+
+    empty.vt = VT_EMPTY;
+    null.vt = VT_NULL;
+    emptyarray.vt = VT_ARRAY | VT_I4;
+    emptyarray.parray = &emptysafearray;
+    emptysafearray.cDims = 1;
+    emptysafearray.fFeatures = FADF_FIXEDSIZE;
+    emptysafearray.cbElements = 4;
+    emptysafearray.cLocks = 0;
+    emptysafearray.pvData = NULL;
+    emptysafearray.rgsabound[0].cElements = 0;
+    emptysafearray.rgsabound[0].lLbound = 0;
+    i2_0.vt = VT_I2;
+    i2_0.iVal = 0;
+    i2_2.vt = VT_I2;
+    i2_2.iVal = 2;
+    i4_large.vt = VT_I4;
+    i4_large.lVal = 65536;
+    i4_largeneg.vt = VT_I4;
+    i4_largeneg.lVal = -65536;
+    i4_2.vt = VT_I4;
+    i4_2.lVal = 2;
+    ui4.vt = VT_UI4;
+    ui4.ulVal = 2;
+    ui4_large.vt = VT_UI4;
+    ui4_large.ulVal = 65536;
+    str_2.vt = VT_BSTR;
+    str_2.bstrVal = SysAllocString(str_2W);
+    str_02.vt = VT_BSTR;
+    str_02.bstrVal = SysAllocString(str_02W);
+    str_b.vt = VT_BSTR;
+    str_b.bstrVal = SysAllocString(str_bW);
+    r4_0.vt = VT_R4;
+    r4_0.fltVal = 0.0f;
+    r4_2.vt = VT_R4;
+    r4_2.fltVal = 2.0f;
+    r4_21.vt = VT_R4;
+    r4_21.fltVal = 2.1f;
+    r8_0.vt = VT_R8;
+    r8_0.dblVal = 0.0;
+    r8_2.vt = VT_R8;
+    r8_2.dblVal = 2.0;
+
+    /* don't test NULL values, this segfaults on native */
+
+    res = VariantCompare(&empty, &empty);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&empty, &null);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&null, &emptyarray);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&empty, &i2_0);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&null, &i2_0);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_0, &null);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_0, &empty);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_2, &i2_0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_0, &i2_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&ui4, &ui4_large);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&ui4_large, &ui4);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_0, &i4_large);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare( &i4_large, &i2_0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_0, &i4_largeneg);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_largeneg, &i2_0);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_large, &i2_0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_largeneg, &i2_0);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_2, &i4_2);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&i2_2, &str_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_2, &str_02);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&str_2, &i2_2);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&str_02, &i2_2);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&str_02, &str_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&str_02, &str_b);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&str_2, &str_02);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_large, &str_b);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    /* VT_R4/VT_R8 */
+    res = VariantCompare(&r4_0, &r8_0);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&r4_0, &r4_0);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&r4_0, &r4_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&r4_2, &r4_0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&r8_0, &r8_0);
+    ok(res == 0, "res=%i\n", res);
+
+    res = VariantCompare(&r8_0, &r8_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&r8_2, &r8_0);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    /* float <> int */
+    res = VariantCompare(&r4_2, &i4_largeneg);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&r4_2, &i4_large);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_large, &r4_2);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i4_largeneg, &r4_2);
+    todo_wine
+    ok(res == -1, "res=%i\n", res);
+
+    res = VariantCompare(&r4_21, &i2_2);
+    todo_wine
+    ok(res == 1, "res=%i\n", res);
+
+    res = VariantCompare(&i2_2, &r4_21);
+    ok(res == 0, "res=%i\n", res);
+
+    SysFreeString(str_2.bstrVal);
+    SysFreeString(str_02.bstrVal);
+    SysFreeString(str_b.bstrVal);
+}
+
 static void test_intconversions(void)
 {
     PROPVARIANT propvar;
@@ -3276,6 +3506,7 @@ START_TEST(propsys)
     test_VariantToStringWithDefault();
     test_VariantToString();
     test_VariantToPropVariant();
+    test_VariantCompare();
     test_PropVariantToVariant();
     test_PropVariantGetStringElem();
     test_PropVariantToFileTime();
-- 
GitLab


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

[PATCH v2 6/6] propsys: Implement VariantCompare().

[Eric Pouech]

From: Eric Pouech <[e-mail]>

Signed-off-by: Eric Pouech <[e-mail]>
---
 dlls/propsys/propvar.c       | 57 ++++++++++++++++++++++++++++++++++--
 dlls/propsys/tests/propsys.c | 32 --------------------
 2 files changed, 54 insertions(+), 35 deletions(-)

diff --git a/dlls/propsys/propvar.c b/dlls/propsys/propvar.c
index b5f4099f2c6..0ae8caf21ad 100644
--- a/dlls/propsys/propvar.c
+++ b/dlls/propsys/propvar.c
@@ -647,7 +647,6 @@ HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT p
     case VT_UI1:
     {
         LONGLONG res;
-
         hr = PROPVAR_ConvertNumber(propvarSrc, 8, FALSE, &res);
         if (SUCCEEDED(hr))
         {
@@ -1183,10 +1182,62 @@ INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2
     return res;
 }
 
+static inline size_t vt_weight(unsigned vt)
+{
+    switch (vt)
+    {
+    case VT_I1:
+    case VT_UI1:   return sizeof(BYTE);
+    case VT_I2:
+    case VT_UI2:   return sizeof(SHORT);
+    case VT_INT:
+    case VT_UINT:
+    case VT_I4:
+    case VT_UI4:   return sizeof(LONG);
+    case VT_I8:
+    case VT_UI8:   return sizeof(LONGLONG);
+    default:       return 0;
+    }
+}
+
 INT WINAPI VariantCompare(REFVARIANT refvar1, REFVARIANT refvar2)
 {
-    FIXME("%s %s: stub!\n", debugstr_variant(refvar1), debugstr_variant(refvar2));
-    return 0;
+    static const unsigned mask_int =   VTBIT_I1 | VTBIT_I2 | VTBIT_I4 | VTBIT_I8 |
+                                       VTBIT_UI1 | VTBIT_UI2 | VTBIT_UI4 | VTBIT_UI8;
+    static const unsigned mask_float = VTBIT_R4 | VTBIT_R8;
+    unsigned mask1 = refvar1->vt < 8 * sizeof(mask1) ? (1u << refvar1->vt) : 0;
+    unsigned mask2 = refvar2->vt < 8 * sizeof(mask2) ? (1u << refvar2->vt) : 0;
+    unsigned mask  = mask1 | mask2;
+    PROPVARIANT prop_var1, prop_var2;
+    BOOL tst1 = refvar1->vt == VT_EMPTY || refvar1->vt == VT_NULL;
+    BOOL tst2 = refvar2->vt == VT_EMPTY || refvar2->vt == VT_NULL;
+    int ret;
+
+    TRACE("%s %s!\n", debugstr_variant(refvar1), debugstr_variant(refvar2));
+
+    if (tst1 && tst2) return 0;
+    if (tst1)         return -1;
+    if (tst2)         return +1;
+
+    ret = refvar1->vt - refvar2->vt;
+    if ((ret == 0 || (mask1 && mask2 && !(mask & ~(mask_int | mask_float)))) &&
+        VariantToPropVariant(refvar1, &prop_var1) == S_OK)
+    {
+        if (VariantToPropVariant(refvar2, &prop_var2) == S_OK)
+        {
+            /* as PropVariantCompareEx coerces prop_var2 into prop_var1's type,
+             * use the largest integer type if both are integers
+             */
+            BOOL can_swap = mask1 && mask2 && !(mask & ~mask_int);
+            if (!can_swap || vt_weight(prop_var1.vt) >= vt_weight(prop_var2.vt))
+                ret = PropVariantCompareEx(&prop_var1, &prop_var2, 0, 0);
+            else
+                ret = -PropVariantCompareEx(&prop_var2, &prop_var1, 0, 0);
+            if (prop_var2.vt == VT_BSTR) SysFreeString(prop_var2.bstrVal);
+        }
+        if (prop_var1.vt == VT_BSTR) SysFreeString(prop_var1.bstrVal);
+    }
+    return ret < 0 ? -1 : (ret > 0 ? +1 : 0);
 }
 
 HRESULT WINAPI PropVariantToVariant(const PROPVARIANT *propvar, VARIANT *var)
diff --git a/dlls/propsys/tests/propsys.c b/dlls/propsys/tests/propsys.c
index 82fdb59c5e9..a814e92d77f 100644
--- a/dlls/propsys/tests/propsys.c
+++ b/dlls/propsys/tests/propsys.c
@@ -1088,98 +1088,75 @@ static void test_VariantCompare(void)
     ok(res == 0, "res=%i\n", res);
 
     res = VariantCompare(&null, &emptyarray);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&empty, &i2_0);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&null, &i2_0);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&i2_0, &null);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_0, &empty);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_2, &i2_0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_0, &i2_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&ui4, &ui4_large);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&ui4_large, &ui4);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_0, &i4_large);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare( &i4_large, &i2_0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_0, &i4_largeneg);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i4_largeneg, &i2_0);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&i4_large, &i2_0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i4_largeneg, &i2_0);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&i2_2, &i4_2);
     ok(res == 0, "res=%i\n", res);
 
     res = VariantCompare(&i2_2, &str_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&i2_2, &str_02);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&str_2, &i2_2);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&str_02, &i2_2);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&str_02, &str_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&str_02, &str_b);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&str_2, &str_02);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i4_large, &str_b);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     /* VT_R4/VT_R8 */
@@ -1190,43 +1167,34 @@ static void test_VariantCompare(void)
     ok(res == 0, "res=%i\n", res);
 
     res = VariantCompare(&r4_0, &r4_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&r4_2, &r4_0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&r8_0, &r8_0);
     ok(res == 0, "res=%i\n", res);
 
     res = VariantCompare(&r8_0, &r8_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&r8_2, &r8_0);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     /* float <> int */
     res = VariantCompare(&r4_2, &i4_largeneg);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&r4_2, &i4_large);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&i4_large, &r4_2);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i4_largeneg, &r4_2);
-    todo_wine
     ok(res == -1, "res=%i\n", res);
 
     res = VariantCompare(&r4_21, &i2_2);
-    todo_wine
     ok(res == 1, "res=%i\n", res);
 
     res = VariantCompare(&i2_2, &r4_21);
-- 
GitLab

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

[eric pouech (＠epo)]

V2 pushed: changes / V1

* added tests for int\<\>float conversion in `PropVariantCompareEx`
* fixed tha failing tests in `PropVariant`CompareEx
* added tests for int\<\>float conversion in `VariantCompare`
* updated `VariantCompare` implementation to pass the tests

@piotr didn't use your test proposal as toying with float equalities (after conversion from integer) is subject to rouding effetcs (could work with 2 but not with 3); used instead int/2 vs float/2.1 so that we can infer what's coerced; and since op is non commutative, added the two way tests

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/10196#note_130611

[eric pouech (＠epo)]

On Thu Feb 26 14:01:04 2026 +0000, Piotr Caban wrote:
> Please add tests for comparing integers and floats (and fix the
> implementation). Here's an example of a test that currently fails:
> ```c
> res = VariantCompare(&r4_2, &i2_2);
> ok(res == 0, "res=%i\n", res);
> ```
> done in V2

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/10196#note_130612

[Piotr Caban (＠piotr)]

One of the if conditions looks suspicious so I have written following tests:

```c
VARIANT r4, r8, i1, i2;

V_VT(&r4) = VT_R4;
V_R4(&r4) = 3.4028234663852886e+038; /* FLT_MAX */
V_VT(&r8) = VT_R8;
V_R8(&r8) = 3.4028234663852890e+038; /* > FLT_MAX */
res = VariantCompare(&r4, &r8);
ok(!res, "res=%i\n", res);
res = VariantCompare(&r8, &r4);
ok(!res, "res=%i\n", res);

V_VT(&i1) = VT_I1;
V_I1(&i1) = 127;
V_VT(&i2) = VT_I2;
V_I2(&i2) = 128;
res = VariantCompare(&i1, &i2);
ok(!res, "res=%i\n", res);
res = VariantCompare(&i2, &i1);
ok(!res, "res=%i\n", res);
```

while I was expecting different results on Windows it fails on Wine.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/10196#note_130614