ReactOS 0.4.15-dev-6669-g8227c5d
propsys.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "initguid.h"
#include "propsys.h"
#include "propvarutil.h"
#include "strsafe.h"
#include "wine/test.h"
Include dependency graph for propsys.c:

Go to the source code of this file.

Macros

#define COBJMACROS
 
#define NONAMELESSUNION
 
#define GUID_MEMBERS(g)   {(g).Data1, (g).Data2, (g).Data3, {(g).Data4[0], (g).Data4[1], (g).Data4[2], (g).Data4[3], (g).Data4[4], (g).Data4[5], (g).Data4[6], (g).Data4[7]}}
 

Functions

 DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 
 DEFINE_GUID (dummy_guid, 0xdeadbeef, 0xdead, 0xbeef, 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0xba, 0xbe)
 
 DEFINE_GUID (expect_guid, 0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12)
 
static int strcmp_wa (LPCWSTR strw, const char *stra)
 
static void test_PSStringFromPropertyKey (void)
 
static void test_PSPropertyKeyFromString (void)
 
static void test_PSRefreshPropertySchema (void)
 
static void test_InitPropVariantFromGUIDAsString (void)
 
static void test_InitPropVariantFromBuffer (void)
 
static void test_PropVariantToGUID (void)
 
static void test_PropVariantToStringAlloc (void)
 
static void test_PropVariantCompare (void)
 
static void test_intconversions (void)
 
static void test_PropVariantToBoolean (void)
 
static void test_PropVariantToStringWithDefault (void)
 
static void test_PropVariantChangeType_LPWSTR (void)
 
static void test_InitPropVariantFromCLSID (void)
 
static void test_PropVariantToDouble (void)
 
static void test_PropVariantToString (void)
 
static void test_PropVariantToBuffer (void)
 
 START_TEST (propsys)
 

Variables

static const char topic [] = "wine topic"
 
static const WCHAR topicW [] = {'w','i','n','e',' ','t','o','p','i','c',0}
 
static const WCHAR emptyW [] = {0}
 

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file propsys.c.

◆ GUID_MEMBERS

#define GUID_MEMBERS (   g)    {(g).Data1, (g).Data2, (g).Data3, {(g).Data4[0], (g).Data4[1], (g).Data4[2], (g).Data4[3], (g).Data4[4], (g).Data4[5], (g).Data4[6], (g).Data4[7]}}

Definition at line 42 of file propsys.c.

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 27 of file propsys.c.

Function Documentation

◆ DEFINE_GUID() [1/3]

DEFINE_GUID ( dummy_guid  ,
0xdeadbeef  ,
0xdead  ,
0xbeef  ,
0xde  ,
0xad  ,
0xbe  ,
0xef  ,
0xca  ,
0xfe  ,
0xba  ,
0xbe   
)

◆ DEFINE_GUID() [2/3]

DEFINE_GUID ( expect_guid  ,
0x12345678  ,
0x1234  ,
0x1234  ,
0x12  ,
0x34  ,
0x12  ,
0x34  ,
0x56  ,
0x78  ,
0x90  ,
0x12   
)

◆ DEFINE_GUID() [3/3]

DEFINE_GUID ( GUID_NULL  ,
,
,
,
,
,
,
,
,
,
,
 
)

◆ START_TEST()

START_TEST ( propsys  )

Definition at line 1584 of file propsys.c.

1585{
1602}
static void test_PSRefreshPropertySchema(void)
Definition: propsys.c:439
static void test_PropVariantToBuffer(void)
Definition: propsys.c:1476
static void test_PropVariantCompare(void)
Definition: propsys.c:660
static void test_PropVariantToStringWithDefault(void)
Definition: propsys.c:1177
static void test_intconversions(void)
Definition: propsys.c:846
static void test_InitPropVariantFromCLSID(void)
Definition: propsys.c:1313
static void test_InitPropVariantFromGUIDAsString(void)
Definition: propsys.c:457
static void test_PSPropertyKeyFromString(void)
Definition: propsys.c:158
static void test_PropVariantToBoolean(void)
Definition: propsys.c:966
static void test_PropVariantToString(void)
Definition: propsys.c:1387
static void test_InitPropVariantFromBuffer(void)
Definition: propsys.c:505
static void test_PropVariantChangeType_LPWSTR(void)
Definition: propsys.c:1277
static void test_PSStringFromPropertyKey(void)
Definition: propsys.c:55
static void test_PropVariantToGUID(void)
Definition: propsys.c:559
static void test_PropVariantToStringAlloc(void)
Definition: propsys.c:632
static void test_PropVariantToDouble(void)
Definition: propsys.c:1331

◆ strcmp_wa()

static int strcmp_wa ( LPCWSTR  strw,
const char stra 
)
static

Definition at line 48 of file propsys.c.

49{
50 CHAR buf[512];
51 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
52 return lstrcmpA(stra, buf);
53}
#define NULL
Definition: types.h:112
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
int WINAPI lstrcmpA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:18
static const char * strw(LPCWSTR x)
Definition: actctx.c:49
char CHAR
Definition: xmlstorage.h:175

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToString().

◆ test_InitPropVariantFromBuffer()

static void test_InitPropVariantFromBuffer ( void  )
static

Definition at line 505 of file propsys.c.

506{
507 static const char data_in[] = "test";
508 PROPVARIANT propvar;
509 VARIANT var;
511 void *data_out;
512 LONG size;
513
514 hres = InitPropVariantFromBuffer(NULL, 0, &propvar);
515 ok(hres == S_OK, "InitPropVariantFromBuffer returned %x\n", hres);
516 ok(propvar.vt == (VT_VECTOR|VT_UI1), "propvar.vt = %d\n", propvar.vt);
517 ok(propvar.u.caub.cElems == 0, "cElems = %d\n", propvar.u.caub.cElems == 0);
518 PropVariantClear(&propvar);
519
520 hres = InitPropVariantFromBuffer(data_in, 4, &propvar);
521 ok(hres == S_OK, "InitPropVariantFromBuffer returned %x\n", hres);
522 ok(propvar.vt == (VT_VECTOR|VT_UI1), "propvar.vt = %d\n", propvar.vt);
523 ok(propvar.u.caub.cElems == 4, "cElems = %d\n", propvar.u.caub.cElems == 0);
524 ok(!memcmp(propvar.u.caub.pElems, data_in, 4), "Data inside array is incorrect\n");
525 PropVariantClear(&propvar);
526
528 ok(hres == S_OK, "InitVariantFromBuffer returned %x\n", hres);
529 ok(V_VT(&var) == (VT_ARRAY|VT_UI1), "V_VT(&var) = %d\n", V_VT(&var));
531 ok(size == 1, "SafeArrayGetDim returned %d\n", size);
533 ok(hres == S_OK, "SafeArrayGetLBound returned %x\n", hres);
534 ok(size == 0, "LBound = %d\n", size);
536 ok(hres == S_OK, "SafeArrayGetUBound returned %x\n", hres);
537 ok(size == -1, "UBound = %d\n", size);
539
540 hres = InitVariantFromBuffer(data_in, 4, &var);
541 ok(hres == S_OK, "InitVariantFromBuffer returned %x\n", hres);
542 ok(V_VT(&var) == (VT_ARRAY|VT_UI1), "V_VT(&var) = %d\n", V_VT(&var));
544 ok(size == 1, "SafeArrayGetDim returned %d\n", size);
546 ok(hres == S_OK, "SafeArrayGetLBound returned %x\n", hres);
547 ok(size == 0, "LBound = %d\n", size);
549 ok(hres == S_OK, "SafeArrayGetUBound returned %x\n", hres);
550 ok(size == 3, "UBound = %d\n", size);
551 hres = SafeArrayAccessData(V_ARRAY(&var), &data_out);
552 ok(hres == S_OK, "SafeArrayAccessData failed %x\n", hres);
553 ok(!memcmp(data_in, data_out, 4), "Data inside safe array is incorrect\n");
555 ok(hres == S_OK, "SafeArrayUnaccessData failed %x\n", hres);
557}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ok(value,...)
Definition: atltest.h:57
@ VT_ARRAY
Definition: compat.h:2341
@ VT_VECTOR
Definition: compat.h:2340
@ VT_UI1
Definition: compat.h:2311
HRESULT WINAPI PropVariantClear(PROPVARIANT *pvar)
Definition: ole2.c:2968
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
Definition: safearray.c:1033
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
Definition: safearray.c:1094
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
Definition: safearray.c:1066
HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
Definition: propvar.c:626
HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
Definition: propvar.c:653
GLsizeiptr size
Definition: glext.h:5919
#define S_OK
Definition: intsafe.h:52
const char * var
Definition: shader.c:5666
HRESULT hres
Definition: protocol.c:465
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_VT(A)
Definition: oleauto.h:211
long LONG
Definition: pedump.c:60
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648

Referenced by START_TEST().

◆ test_InitPropVariantFromCLSID()

static void test_InitPropVariantFromCLSID ( void  )
static

Definition at line 1313 of file propsys.c.

1314{
1315 PROPVARIANT propvar;
1316 GUID clsid;
1317 HRESULT hr;
1318
1319 memset(&propvar, 0, sizeof(propvar));
1320 propvar.vt = VT_I4;
1321 propvar.u.lVal = 15;
1322
1323 memset(&clsid, 0xcc, sizeof(clsid));
1324 hr = InitPropVariantFromCLSID(&clsid, &propvar);
1325 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1326 ok(propvar.vt == VT_CLSID, "Unexpected type %d.\n", propvar.vt);
1327 ok(IsEqualGUID(propvar.u.puuid, &clsid), "Unexpected puuid value.\n");
1328 PropVariantClear(&propvar);
1329}
@ VT_CLSID
Definition: compat.h:2337
@ VT_I4
Definition: compat.h:2298
HRESULT WINAPI InitPropVariantFromCLSID(REFCLSID clsid, PROPVARIANT *ppropvar)
Definition: propvar.c:640
REFCLSID clsid
Definition: msctf.c:82
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183

Referenced by START_TEST().

◆ test_InitPropVariantFromGUIDAsString()

static void test_InitPropVariantFromGUIDAsString ( void  )
static

Definition at line 457 of file propsys.c.

458{
459 PROPVARIANT propvar;
460 VARIANT var;
462 int i;
463
464 const struct {
466 const char *str;
467 } testcases[] = {
468 {&IID_NULL, "{00000000-0000-0000-0000-000000000000}" },
469 {&dummy_guid, "{DEADBEEF-DEAD-BEEF-DEAD-BEEFCAFEBABE}" },
470 };
471
473 ok(hres == E_FAIL, "InitPropVariantFromGUIDAsString returned %x\n", hres);
474
475 if(0) {
476 /* Returns strange data on Win7, crashes on older systems */
478
479 /* Crashes on windows */
482 }
483
484 for(i=0; i < ARRAY_SIZE(testcases); i++) {
485 memset(&propvar, 0, sizeof(PROPVARIANT));
486 hres = InitPropVariantFromGUIDAsString(testcases[i].guid, &propvar);
487 ok(hres == S_OK, "%d) InitPropVariantFromGUIDAsString returned %x\n", i, hres);
488 ok(propvar.vt == VT_LPWSTR, "%d) propvar.vt = %d\n", i, propvar.vt);
489 ok(!strcmp_wa(propvar.u.pwszVal, testcases[i].str), "%d) propvar.u.pwszVal = %s\n",
490 i, wine_dbgstr_w(propvar.u.pwszVal));
491 CoTaskMemFree(propvar.u.pwszVal);
492
493 memset(&var, 0, sizeof(VARIANT));
494 hres = InitVariantFromGUIDAsString(testcases[i].guid, &var);
495 ok(hres == S_OK, "%d) InitVariantFromGUIDAsString returned %x\n", i, hres);
496 ok(V_VT(&var) == VT_BSTR, "%d) V_VT(&var) = %d\n", i, V_VT(&var));
497 ok(SysStringLen(V_BSTR(&var)) == 38, "SysStringLen returned %d\n",
499 ok(!strcmp_wa(V_BSTR(&var), testcases[i].str), "%d) V_BSTR(&var) = %s\n",
502 }
503}
#define ARRAY_SIZE(A)
Definition: main.h:33
#define E_FAIL
Definition: ddrawi.h:102
@ VT_BSTR
Definition: compat.h:2303
@ VT_LPWSTR
Definition: compat.h:2325
HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
Definition: propvar.c:608
HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
Definition: propvar.c:592
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define wine_dbgstr_w
Definition: kernel32.h:34
const GUID * guid
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
#define V_BSTR(A)
Definition: oleauto.h:226
static int strcmp_wa(LPCWSTR strw, const char *stra)
Definition: propsys.c:48
#define IID_NULL
Definition: guiddef.h:98
const WCHAR * str
Definition: scsiwmi.h:51

Referenced by START_TEST().

◆ test_intconversions()

static void test_intconversions ( void  )
static

Definition at line 846 of file propsys.c.

847{
848 PROPVARIANT propvar;
849 SHORT sval;
850 USHORT usval;
851 LONG lval;
852 ULONG ulval;
854 ULONGLONG ullval;
855 HRESULT hr;
856
857 propvar.vt = 0xdead;
858 hr = PropVariantClear(&propvar);
859 ok (FAILED(hr), "PropVariantClear fails on invalid vt.\n");
860
861 propvar.vt = VT_I8;
862 PropVariantClear(&propvar);
863
864 propvar.vt = VT_I8;
865 propvar.u.hVal.QuadPart = (ULONGLONG)1 << 63;
866
867 hr = PropVariantToInt64(&propvar, &llval);
868 ok(hr == S_OK, "hr=%x\n", hr);
869 ok(llval == (ULONGLONG)1 << 63, "got wrong value %s\n", wine_dbgstr_longlong(llval));
870
871 hr = PropVariantToUInt64(&propvar, &ullval);
873
874 hr = PropVariantToInt32(&propvar, &lval);
876
877 hr = PropVariantToUInt32(&propvar, &ulval);
879
880 hr = PropVariantToInt16(&propvar, &sval);
882
883 hr = PropVariantToUInt16(&propvar, &usval);
885
886 propvar.vt = VT_UI8;
887 propvar.u.uhVal.QuadPart = 5;
888
889 hr = PropVariantToInt64(&propvar, &llval);
890 ok(hr == S_OK, "hr=%x\n", hr);
891 ok(llval == 5, "got wrong value %s\n", wine_dbgstr_longlong(llval));
892
893 hr = PropVariantToUInt64(&propvar, &ullval);
894 ok(hr == S_OK, "hr=%x\n", hr);
895 ok(ullval == 5, "got wrong value %s\n", wine_dbgstr_longlong(ullval));
896
897 hr = PropVariantToInt32(&propvar, &lval);
898 ok(hr == S_OK, "hr=%x\n", hr);
899 ok(lval == 5, "got wrong value %d\n", lval);
900
901 hr = PropVariantToUInt32(&propvar, &ulval);
902 ok(hr == S_OK, "hr=%x\n", hr);
903 ok(ulval == 5, "got wrong value %d\n", ulval);
904
905 hr = PropVariantToInt16(&propvar, &sval);
906 ok(hr == S_OK, "hr=%x\n", hr);
907 ok(sval == 5, "got wrong value %d\n", sval);
908
909 hr = PropVariantToUInt16(&propvar, &usval);
910 ok(hr == S_OK, "hr=%x\n", hr);
911 ok(usval == 5, "got wrong value %d\n", usval);
912
913 propvar.vt = VT_I8;
914 propvar.u.hVal.QuadPart = -5;
915
916 hr = PropVariantToInt64(&propvar, &llval);
917 ok(hr == S_OK, "hr=%x\n", hr);
918 ok(llval == -5, "got wrong value %s\n", wine_dbgstr_longlong(llval));
919
920 hr = PropVariantToUInt64(&propvar, &ullval);
922
923 hr = PropVariantToInt32(&propvar, &lval);
924 ok(hr == S_OK, "hr=%x\n", hr);
925 ok(lval == -5, "got wrong value %d\n", lval);
926
927 hr = PropVariantToUInt32(&propvar, &ulval);
929
930 hr = PropVariantToInt16(&propvar, &sval);
931 ok(hr == S_OK, "hr=%x\n", hr);
932 ok(sval == -5, "got wrong value %d\n", sval);
933
934 hr = PropVariantToUInt16(&propvar, &usval);
936
937 propvar.vt = VT_UI4;
938 propvar.u.ulVal = 6;
939
940 hr = PropVariantToInt64(&propvar, &llval);
941 ok(hr == S_OK, "hr=%x\n", hr);
942 ok(llval == 6, "got wrong value %s\n", wine_dbgstr_longlong(llval));
943
944 propvar.vt = VT_I4;
945 propvar.u.lVal = -6;
946
947 hr = PropVariantToInt64(&propvar, &llval);
948 ok(hr == S_OK, "hr=%x\n", hr);
949 ok(llval == -6, "got wrong value %s\n", wine_dbgstr_longlong(llval));
950
951 propvar.vt = VT_UI2;
952 propvar.u.uiVal = 7;
953
954 hr = PropVariantToInt64(&propvar, &llval);
955 ok(hr == S_OK, "hr=%x\n", hr);
956 ok(llval == 7, "got wrong value %s\n", wine_dbgstr_longlong(llval));
957
958 propvar.vt = VT_I2;
959 propvar.u.iVal = -7;
960
961 hr = PropVariantToInt64(&propvar, &llval);
962 ok(hr == S_OK, "hr=%x\n", hr);
963 ok(llval == -7, "got wrong value %s\n", wine_dbgstr_longlong(llval));
964}
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
@ VT_UI8
Definition: compat.h:2315
@ VT_UI2
Definition: compat.h:2312
@ VT_I8
Definition: compat.h:2314
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
Definition: propvar.c:186
HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
Definition: propvar.c:210
HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
Definition: propvar.c:198
HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
Definition: propvar.c:234
HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
Definition: propvar.c:222
HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
Definition: propvar.c:174
#define FAILED(hr)
Definition: intsafe.h:51
short SHORT
Definition: pedump.c:59
unsigned short USHORT
Definition: pedump.c:61
Llong llval
Definition: format.c:276
int64_t LONGLONG
Definition: typedefs.h:68
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_ARITHMETIC_OVERFLOW
Definition: winerror.h:351

Referenced by START_TEST().

◆ test_PropVariantChangeType_LPWSTR()

static void test_PropVariantChangeType_LPWSTR ( void  )
static

Definition at line 1277 of file propsys.c.

1278{
1279 PROPVARIANT dest, src;
1280 HRESULT hr;
1281
1282 PropVariantInit(&dest);
1283
1284 src.vt = VT_NULL;
1286 ok(hr == S_OK, "hr=%x\n", hr);
1287 ok(dest.vt == VT_LPWSTR, "got %d\n", dest.vt);
1288 ok(!lstrcmpW(dest.u.pwszVal, emptyW), "got %s\n", wine_dbgstr_w(dest.u.pwszVal));
1291
1292 src.vt = VT_LPSTR;
1293 src.u.pszVal = CoTaskMemAlloc(strlen(topic)+1);
1294 strcpy(src.u.pszVal, topic);
1296 ok(hr == S_OK, "hr=%x\n", hr);
1297 ok(dest.vt == VT_LPWSTR, "got %d\n", dest.vt);
1298 ok(!lstrcmpW(dest.u.pwszVal, topicW), "got %s\n", wine_dbgstr_w(dest.u.pwszVal));
1301
1302 src.vt = VT_LPWSTR;
1303 src.u.pwszVal = CoTaskMemAlloc( (lstrlenW(topicW)+1) * sizeof(WCHAR));
1304 lstrcpyW(src.u.pwszVal, topicW);
1306 ok(hr == S_OK, "hr=%x\n", hr);
1307 ok(dest.vt == VT_LPWSTR, "got %d\n", dest.vt);
1308 ok(!lstrcmpW(dest.u.pwszVal, topicW), "got %s\n", wine_dbgstr_w(dest.u.pwszVal));
1311}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define lstrcpyW
Definition: compat.h:749
@ VT_LPSTR
Definition: compat.h:2324
@ VT_NULL
Definition: compat.h:2296
#define lstrlenW
Definition: compat.h:750
HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
Definition: propvar.c:428
GLenum src
Definition: glext.h:6340
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
static char * dest
Definition: rtl.c:135
static const WCHAR topicW[]
Definition: propsys.c:45
static const WCHAR emptyW[]
Definition: propsys.c:46
static const char topic[]
Definition: propsys.c:44
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ test_PropVariantCompare()

static void test_PropVariantCompare ( void  )
static

Definition at line 660 of file propsys.c.

661{
662 PROPVARIANT empty, null, emptyarray, i2_0, i2_2, i4_large, i4_largeneg, i4_2, str_2, str_02, str_b;
663 PROPVARIANT clsid_null, clsid, clsid2, r4_0, r4_2, r8_0, r8_2;
664 INT res;
665 static const WCHAR str_2W[] = {'2', 0};
666 static const WCHAR str_02W[] = {'0', '2', 0};
667 static const WCHAR str_bW[] = {'b', 0};
668 SAFEARRAY emptysafearray;
669
670 PropVariantInit(&empty);
671 PropVariantInit(&null);
672 PropVariantInit(&emptyarray);
673 PropVariantInit(&i2_0);
674 PropVariantInit(&i2_2);
675 PropVariantInit(&i4_large);
676 PropVariantInit(&i4_largeneg);
677 PropVariantInit(&i4_2);
678 PropVariantInit(&str_2);
679 PropVariantInit(&str_b);
680
681 empty.vt = VT_EMPTY;
682 null.vt = VT_NULL;
683 emptyarray.vt = VT_ARRAY | VT_I4;
684 emptyarray.u.parray = &emptysafearray;
685 emptysafearray.cDims = 1;
686 emptysafearray.fFeatures = FADF_FIXEDSIZE;
687 emptysafearray.cbElements = 4;
688 emptysafearray.cLocks = 0;
689 emptysafearray.pvData = NULL;
690 emptysafearray.rgsabound[0].cElements = 0;
691 emptysafearray.rgsabound[0].lLbound = 0;
692 i2_0.vt = VT_I2;
693 i2_0.u.iVal = 0;
694 i2_2.vt = VT_I2;
695 i2_2.u.iVal = 2;
696 i4_large.vt = VT_I4;
697 i4_large.u.lVal = 65536;
698 i4_largeneg.vt = VT_I4;
699 i4_largeneg.u.lVal = -65536;
700 i4_2.vt = VT_I4;
701 i4_2.u.lVal = 2;
702 str_2.vt = VT_BSTR;
703 str_2.u.bstrVal = SysAllocString(str_2W);
704 str_02.vt = VT_BSTR;
705 str_02.u.bstrVal = SysAllocString(str_02W);
706 str_b.vt = VT_BSTR;
707 str_b.u.bstrVal = SysAllocString(str_bW);
708 clsid_null.vt = VT_CLSID;
709 clsid_null.u.puuid = NULL;
710 clsid.vt = VT_CLSID;
711 clsid.u.puuid = (GUID *)&dummy_guid;
712 clsid2.vt = VT_CLSID;
713 clsid2.u.puuid = (GUID *)&GUID_NULL;
714 r4_0.vt = VT_R4;
715 r4_0.u.fltVal = 0.0f;
716 r4_2.vt = VT_R4;
717 r4_2.u.fltVal = 2.0f;
718 r8_0.vt = VT_R8;
719 r8_0.u.dblVal = 0.0;
720 r8_2.vt = VT_R8;
721 r8_2.u.dblVal = 2.0;
722
724 ok(res == 0, "res=%i\n", res);
725
727 ok(res == 0, "res=%i\n", res);
728
729 res = PropVariantCompareEx(&null, &emptyarray, 0, 0);
730 ok(res == 0, "res=%i\n", res);
731
732 res = PropVariantCompareEx(&null, &i2_0, 0, 0);
733 ok(res == -1, "res=%i\n", res);
734
735 res = PropVariantCompareEx(&i2_0, &null, 0, 0);
736 ok(res == 1, "res=%i\n", res);
737
739 ok(res == 1, "res=%i\n", res);
740
742 ok(res == -1, "res=%i\n", res);
743
744 res = PropVariantCompareEx(&i2_2, &i2_0, 0, 0);
745 ok(res == 1, "res=%i\n", res);
746
747 res = PropVariantCompareEx(&i2_0, &i2_2, 0, 0);
748 ok(res == -1, "res=%i\n", res);
749
750 /* Always return -1 if second value cannot be converted to first type */
751 res = PropVariantCompareEx(&i2_0, &i4_large, 0, 0);
752 ok(res == -1, "res=%i\n", res);
753
754 res = PropVariantCompareEx(&i2_0, &i4_largeneg, 0, 0);
755 ok(res == -1, "res=%i\n", res);
756
757 res = PropVariantCompareEx(&i4_large, &i2_0, 0, 0);
758 ok(res == 1, "res=%i\n", res);
759
760 res = PropVariantCompareEx(&i4_largeneg, &i2_0, 0, 0);
761 ok(res == -1, "res=%i\n", res);
762
763 res = PropVariantCompareEx(&i2_2, &i4_2, 0, 0);
764 ok(res == 0, "res=%i\n", res);
765
766 res = PropVariantCompareEx(&i2_2, &str_2, 0, 0);
767 ok(res == 0, "res=%i\n", res);
768
769 res = PropVariantCompareEx(&i2_2, &str_02, 0, 0);
770 ok(res == 0, "res=%i\n", res);
771
772 res = PropVariantCompareEx(&str_2, &i2_2, 0, 0);
773 todo_wine ok(res == 0, "res=%i\n", res);
774
775 res = PropVariantCompareEx(&str_02, &i2_2, 0, 0);
776 ok(res == -1, "res=%i\n", res);
777
778 res = PropVariantCompareEx(&str_02, &str_2, 0, 0);
779 ok(res == -1, "res=%i\n", res);
780
781 res = PropVariantCompareEx(&str_02, &str_b, 0, 0);
782 ok(res == -1, "res=%i\n", res);
783
784 res = PropVariantCompareEx(&str_2, &str_02, 0, 0);
785 ok(res == 1, "res=%i\n", res);
786
787 res = PropVariantCompareEx(&i4_large, &str_b, 0, 0);
788 todo_wine ok(res == -5 /* ??? */, "res=%i\n", res);
789
790 /* VT_CLSID */
791 res = PropVariantCompareEx(&clsid_null, &clsid_null, 0, 0);
792 ok(res == 0, "res=%i\n", res);
793
794 res = PropVariantCompareEx(&clsid_null, &clsid_null, 0, PVCF_TREATEMPTYASGREATERTHAN);
795 ok(res == 0, "res=%i\n", res);
796
798 ok(res == 0, "res=%i\n", res);
799
800 res = PropVariantCompareEx(&clsid, &clsid2, 0, 0);
801 ok(res == 1, "res=%i\n", res);
802
803 res = PropVariantCompareEx(&clsid2, &clsid, 0, 0);
804 ok(res == -1, "res=%i\n", res);
805
806 res = PropVariantCompareEx(&clsid_null, &clsid, 0, 0);
807 ok(res == -1, "res=%i\n", res);
808
809 res = PropVariantCompareEx(&clsid, &clsid_null, 0, 0);
810 ok(res == 1, "res=%i\n", res);
811
813 ok(res == 1, "res=%i\n", res);
814
816 ok(res == -1, "res=%i\n", res);
817
818 /* VT_R4/VT_R8 */
819 res = PropVariantCompareEx(&r4_0, &r8_0, 0, 0);
821 ok(res == 0, "res=%i\n", res);
822
823 res = PropVariantCompareEx(&r4_0, &r4_0, 0, 0);
824 ok(res == 0, "res=%i\n", res);
825
826 res = PropVariantCompareEx(&r4_0, &r4_2, 0, 0);
827 ok(res == -1, "res=%i\n", res);
828
829 res = PropVariantCompareEx(&r4_2, &r4_0, 0, 0);
830 ok(res == 1, "res=%i\n", res);
831
832 res = PropVariantCompareEx(&r8_0, &r8_0, 0, 0);
833 ok(res == 0, "res=%i\n", res);
834
835 res = PropVariantCompareEx(&r8_0, &r8_2, 0, 0);
836 ok(res == -1, "res=%i\n", res);
837
838 res = PropVariantCompareEx(&r8_2, &r8_0, 0, 0);
839 ok(res == 1, "res=%i\n", res);
840
841 SysFreeString(str_2.u.bstrVal);
842 SysFreeString(str_02.u.bstrVal);
843 SysFreeString(str_b.u.bstrVal);
844}
int null(void)
Definition: ftp.c:1794
static const WCHAR empty[]
Definition: main.c:47
@ VT_R4
Definition: compat.h:2299
@ VT_R8
Definition: compat.h:2300
@ VT_EMPTY
Definition: compat.h:2295
INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2, PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
Definition: propvar.c:814
GLuint res
Definition: glext.h:9613
#define GUID_NULL
Definition: ks.h:106
#define todo_wine
Definition: custom.c:79
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
@ PVCF_TREATEMPTYASGREATERTHAN
Definition: propvarutil.h:57
USHORT fFeatures
Definition: compat.h:2356
SAFEARRAYBOUND rgsabound[1]
Definition: compat.h:2360
ULONG cLocks
Definition: compat.h:2358
USHORT cDims
Definition: compat.h:2355
PVOID pvData
Definition: compat.h:2359
ULONG cbElements
Definition: compat.h:2357
int32_t INT
Definition: typedefs.h:58

Referenced by START_TEST().

◆ test_PropVariantToBoolean()

static void test_PropVariantToBoolean ( void  )
static

Definition at line 966 of file propsys.c.

967{
968 static WCHAR str_0[] = {'0',0};
969 static WCHAR str_1[] = {'1',0};
970 static WCHAR str_7[] = {'7',0};
971 static WCHAR str_n7[] = {'-','7',0};
972 static WCHAR str_true[] = {'t','r','u','e',0};
973 static WCHAR str_true2[] = {'#','T','R','U','E','#',0};
974 static WCHAR str_true_case[] = {'t','R','U','e',0};
975 static WCHAR str_false[] = {'f','a','l','s','e',0};
976 static WCHAR str_false2[] = {'#','F','A','L','S','E','#',0};
977 static WCHAR str_true_space[] = {'t','r','u','e',' ',0};
978 static WCHAR str_yes[] = {'y','e','s',0};
979 PROPVARIANT propvar;
980 HRESULT hr;
981 BOOL val;
982
983 /* VT_BOOL */
984 propvar.vt = VT_BOOL;
985 propvar.u.boolVal = VARIANT_FALSE;
986 val = TRUE;
987 hr = PropVariantToBoolean(&propvar, &val);
988 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
989 ok(val == FALSE, "Unexpected value %d\n", val);
990
991 propvar.vt = VT_BOOL;
992 propvar.u.boolVal = 1;
993 val = TRUE;
994 hr = PropVariantToBoolean(&propvar, &val);
995 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
996 ok(val == FALSE, "Unexpected value %d\n", val);
997
998 propvar.vt = VT_BOOL;
999 propvar.u.boolVal = VARIANT_TRUE;
1000 val = FALSE;
1001 hr = PropVariantToBoolean(&propvar, &val);
1002 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1003 ok(val == TRUE, "Unexpected value %d\n", val);
1004
1005 /* VT_EMPTY */
1006 propvar.vt = VT_EMPTY;
1007 propvar.u.boolVal = VARIANT_TRUE;
1008 val = TRUE;
1009 hr = PropVariantToBoolean(&propvar, &val);
1010 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1011 ok(val == FALSE, "Unexpected value %d\n", val);
1012
1013 /* test integer conversion */
1014 propvar.vt = VT_I4;
1015 propvar.u.lVal = 0;
1016 val = TRUE;
1017 hr = PropVariantToBoolean(&propvar, &val);
1018 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1019 ok(val == FALSE, "Unexpected value %d\n", val);
1020
1021 propvar.vt = VT_I4;
1022 propvar.u.lVal = 1;
1023 val = FALSE;
1024 hr = PropVariantToBoolean(&propvar, &val);
1025 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1026 ok(val == TRUE, "Unexpected value %d\n", val);
1027
1028 propvar.vt = VT_I4;
1029 propvar.u.lVal = 67;
1030 val = FALSE;
1031 hr = PropVariantToBoolean(&propvar, &val);
1032 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1033 ok(val == TRUE, "Unexpected value %d\n", val);
1034
1035 propvar.vt = VT_I4;
1036 propvar.u.lVal = -67;
1037 val = FALSE;
1038 hr = PropVariantToBoolean(&propvar, &val);
1039 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1040 ok(val == TRUE, "Unexpected value %d\n", val);
1041
1042 /* test string conversion */
1043 propvar.vt = VT_LPWSTR;
1044 propvar.u.pwszVal = str_0;
1045 val = TRUE;
1046 hr = PropVariantToBoolean(&propvar, &val);
1047 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1048 ok(val == FALSE, "Unexpected value %d\n", val);
1049
1050 propvar.vt = VT_LPWSTR;
1051 propvar.u.pwszVal = str_1;
1052 val = FALSE;
1053 hr = PropVariantToBoolean(&propvar, &val);
1054 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1055 ok(val == TRUE, "Unexpected value %d\n", val);
1056
1057 propvar.vt = VT_LPWSTR;
1058 propvar.u.pwszVal = str_7;
1059 val = FALSE;
1060 hr = PropVariantToBoolean(&propvar, &val);
1061 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1062 ok(val == TRUE, "Unexpected value %d\n", val);
1063
1064 propvar.vt = VT_LPWSTR;
1065 propvar.u.pwszVal = str_n7;
1066 val = FALSE;
1067 hr = PropVariantToBoolean(&propvar, &val);
1068 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1069 ok(val == TRUE, "Unexpected value %d\n", val);
1070
1071 propvar.vt = VT_LPWSTR;
1072 propvar.u.pwszVal = str_true;
1073 val = FALSE;
1074 hr = PropVariantToBoolean(&propvar, &val);
1075 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1076 ok(val == TRUE, "Unexpected value %d\n", val);
1077
1078 propvar.vt = VT_LPWSTR;
1079 propvar.u.pwszVal = str_true_case;
1080 val = FALSE;
1081 hr = PropVariantToBoolean(&propvar, &val);
1082 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1083 ok(val == TRUE, "Unexpected value %d\n", val);
1084
1085 propvar.vt = VT_LPWSTR;
1086 propvar.u.pwszVal = str_true2;
1087 val = FALSE;
1088 hr = PropVariantToBoolean(&propvar, &val);
1089 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1090 ok(val == TRUE, "Unexpected value %d\n", val);
1091
1092 propvar.vt = VT_LPWSTR;
1093 propvar.u.pwszVal = str_false;
1094 val = TRUE;
1095 hr = PropVariantToBoolean(&propvar, &val);
1096 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1097 ok(val == FALSE, "Unexpected value %d\n", val);
1098
1099 propvar.vt = VT_LPWSTR;
1100 propvar.u.pwszVal = str_false2;
1101 val = TRUE;
1102 hr = PropVariantToBoolean(&propvar, &val);
1103 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1104 ok(val == FALSE, "Unexpected value %d\n", val);
1105
1106 propvar.vt = VT_LPWSTR;
1107 propvar.u.pwszVal = str_true_space;
1108 val = TRUE;
1109 hr = PropVariantToBoolean(&propvar, &val);
1110 ok(hr == DISP_E_TYPEMISMATCH, "Unexpected hr %#x.\n", hr);
1111 ok(val == FALSE, "Unexpected value %d\n", val);
1112
1113 propvar.vt = VT_LPWSTR;
1114 propvar.u.pwszVal = str_yes;
1115 val = TRUE;
1116 hr = PropVariantToBoolean(&propvar, &val);
1117 ok(hr == DISP_E_TYPEMISMATCH, "Unexpected hr %#x.\n", hr);
1118 ok(val == FALSE, "Unexpected value %d\n", val);
1119
1120 propvar.vt = VT_LPWSTR;
1121 propvar.u.pwszVal = NULL;
1122 val = TRUE;
1123 hr = PropVariantToBoolean(&propvar, &val);
1124 ok(hr == DISP_E_TYPEMISMATCH, "Unexpected hr %#x.\n", hr);
1125 ok(val == FALSE, "Unexpected value %d\n", val);
1126
1127 /* VT_LPSTR */
1128 propvar.vt = VT_LPSTR;
1129 propvar.u.pszVal = (char *)"#TruE#";
1130 val = TRUE;
1131 hr = PropVariantToBoolean(&propvar, &val);
1132 ok(hr == DISP_E_TYPEMISMATCH, "Unexpected hr %#x.\n", hr);
1133 ok(val == FALSE, "Unexpected value %d\n", val);
1134
1135 propvar.vt = VT_LPSTR;
1136 propvar.u.pszVal = (char *)"#TRUE#";
1137 val = FALSE;
1138 hr = PropVariantToBoolean(&propvar, &val);
1139 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1140 ok(val == TRUE, "Unexpected value %d\n", val);
1141
1142 propvar.vt = VT_LPSTR;
1143 propvar.u.pszVal = (char *)"tRUe";
1144 val = FALSE;
1145 hr = PropVariantToBoolean(&propvar, &val);
1146 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1147 ok(val == TRUE, "Unexpected value %d\n", val);
1148
1149 propvar.vt = VT_LPSTR;
1150 propvar.u.pszVal = (char *)"#FALSE#";
1151 val = TRUE;
1152 hr = PropVariantToBoolean(&propvar, &val);
1153 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1154 ok(val == FALSE, "Unexpected value %d\n", val);
1155
1156 propvar.vt = VT_LPSTR;
1157 propvar.u.pszVal = (char *)"fALSe";
1158 val = TRUE;
1159 hr = PropVariantToBoolean(&propvar, &val);
1160 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1161 ok(val == FALSE, "Unexpected value %d\n", val);
1162
1163 propvar.vt = VT_LPSTR;
1164 propvar.u.pszVal = (char *)"1";
1165 val = FALSE;
1166 hr = PropVariantToBoolean(&propvar, &val);
1167 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1168 ok(val == TRUE, "Unexpected value %d\n", val);
1169
1170 propvar.vt = VT_LPSTR;
1171 propvar.u.pszVal = (char *)"-1";
1172 hr = PropVariantToBoolean(&propvar, &val);
1173 ok(hr == S_OK, "Unexpected hr %#x.\n", hr);
1174 ok(val == TRUE, "Unexpected value %d\n", val);
1175}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
@ VT_BOOL
Definition: compat.h:2306
HRESULT WINAPI PropVariantToBoolean(REFPROPVARIANT propvarIn, BOOL *ret)
Definition: propvar.c:246
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint GLfloat * val
Definition: glext.h:7180
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514

Referenced by START_TEST().

◆ test_PropVariantToBuffer()

static void test_PropVariantToBuffer ( void  )
static

Definition at line 1476 of file propsys.c.

1477{
1478 PROPVARIANT propvar;
1479 HRESULT hr;
1480 UINT8 data[] = {1,2,3,4,5,6,7,8,9,10};
1481 INT8 data_int8[] = {1,2,3,4,5,6,7,8,9,10};
1482 SAFEARRAY *sa;
1483 SAFEARRAYBOUND sabound;
1484 void *pdata;
1485 UINT8 buffer[256];
1486
1487 hr = InitPropVariantFromBuffer(data, 10, &propvar);
1488 ok(hr == S_OK, "InitPropVariantFromBuffer failed 0x%08x.\n", hr);
1489 hr = PropVariantToBuffer(&propvar, NULL, 0); /* crash when cb isn't zero */
1490 ok(hr == S_OK, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1491 PropVariantClear(&propvar);
1492
1493 hr = InitPropVariantFromBuffer(data, 10, &propvar);
1494 ok(hr == S_OK, "InitPropVariantFromBuffer failed 0x%08x.\n", hr);
1495 hr = PropVariantToBuffer(&propvar, buffer, 10);
1496 ok(hr == S_OK, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1497 ok(!memcmp(buffer, data, 10) && !buffer[10], "got wrong buffer.\n");
1498 memset(buffer, 0, sizeof(buffer));
1499 PropVariantClear(&propvar);
1500
1501 hr = InitPropVariantFromBuffer(data, 10, &propvar);
1502 ok(hr == S_OK, "InitPropVariantFromBuffer failed 0x%08x.\n", hr);
1503 buffer[0] = 99;
1504 hr = PropVariantToBuffer(&propvar, buffer, 11);
1505 ok(hr == E_FAIL, "PropVariantToBuffer returned: 0x%08x.\n", hr);
1506 ok(buffer[0] == 99, "got wrong buffer.\n");
1507 memset(buffer, 0, sizeof(buffer));
1508 PropVariantClear(&propvar);
1509
1510 hr = InitPropVariantFromBuffer(data, 10, &propvar);
1511 ok(hr == S_OK, "InitPropVariantFromBuffer failed 0x%08x.\n", hr);
1512 hr = PropVariantToBuffer(&propvar, buffer, 9);
1513 ok(hr == S_OK, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1514 ok(!memcmp(buffer, data, 9) && !buffer[9], "got wrong buffer.\n");
1515 memset(buffer, 0, sizeof(buffer));
1516 PropVariantClear(&propvar);
1517
1518 PropVariantInit(&propvar);
1519 propvar.vt = VT_ARRAY|VT_UI1;
1520 sabound.lLbound = 0;
1521 sabound.cElements = sizeof(data);
1522 sa = NULL;
1523 sa = SafeArrayCreate(VT_UI1, 1, &sabound);
1524 ok(sa != NULL, "SafeArrayCreate failed.\n");
1526 ok(hr == S_OK, "SafeArrayAccessData failed: 0x%08x.\n", hr);
1527 memcpy(pdata, data, sizeof(data));
1529 ok(hr == S_OK, "SafeArrayUnaccessData failed: 0x%08x.\n", hr);
1530 U(propvar).parray = sa;
1531 buffer[0] = 99;
1532 hr = PropVariantToBuffer(&propvar, buffer, 11);
1533 todo_wine ok(hr == E_FAIL, "PropVariantToBuffer returned: 0x%08x.\n", hr);
1534 ok(buffer[0] == 99, "got wrong buffer.\n");
1535 memset(buffer, 0, sizeof(buffer));
1536 PropVariantClear(&propvar);
1537
1538 PropVariantInit(&propvar);
1539 propvar.vt = VT_ARRAY|VT_UI1;
1540 sabound.lLbound = 0;
1541 sabound.cElements = sizeof(data);
1542 sa = NULL;
1543 sa = SafeArrayCreate(VT_UI1, 1, &sabound);
1544 ok(sa != NULL, "SafeArrayCreate failed.\n");
1546 ok(hr == S_OK, "SafeArrayAccessData failed: 0x%08x.\n", hr);
1547 memcpy(pdata, data, sizeof(data));
1549 ok(hr == S_OK, "SafeArrayUnaccessData failed: 0x%08x.\n", hr);
1550 U(propvar).parray = sa;
1551 hr = PropVariantToBuffer(&propvar, buffer, sizeof(data));
1552 todo_wine ok(hr == S_OK, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1553 todo_wine ok(!memcmp(buffer, data, 10) && !buffer[10], "got wrong buffer.\n");
1554 memset(buffer, 0, sizeof(buffer));
1555 PropVariantClear(&propvar);
1556
1557 PropVariantInit(&propvar);
1558 propvar.vt = VT_VECTOR|VT_I1;
1559 U(propvar).caub.pElems = CoTaskMemAlloc(sizeof(data_int8));
1560 U(propvar).caub.cElems = sizeof(data_int8);
1561 memcpy(U(propvar).caub.pElems, data_int8, sizeof(data_int8));
1562 hr = PropVariantToBuffer(&propvar, buffer, sizeof(data_int8));
1563 ok(hr == E_INVALIDARG, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1564 PropVariantClear(&propvar);
1565
1566 PropVariantInit(&propvar);
1567 propvar.vt = VT_ARRAY|VT_I1;
1568 sabound.lLbound = 0;
1569 sabound.cElements = sizeof(data_int8);
1570 sa = NULL;
1571 sa = SafeArrayCreate(VT_I1, 1, &sabound);
1572 ok(sa != NULL, "SafeArrayCreate failed.\n");
1574 ok(hr == S_OK, "SafeArrayAccessData failed: 0x%08x.\n", hr);
1575 memcpy(pdata, data_int8, sizeof(data_int8));
1577 ok(hr == S_OK, "SafeArrayUnaccessData failed: 0x%08x.\n", hr);
1578 U(propvar).parray = sa;
1579 hr = PropVariantToBuffer(&propvar, buffer, sizeof(data_int8));
1580 ok(hr == E_INVALIDARG, "PropVariantToBuffer failed: 0x%08x.\n", hr);
1581 PropVariantClear(&propvar);
1582}
signed char INT8
unsigned char UINT8
static struct sockaddr_in sa
Definition: adnsresfilter.c:69
#define U(x)
Definition: wordpad.c:45
#define E_INVALIDARG
Definition: ddrawi.h:101
@ VT_I1
Definition: compat.h:2310
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
Definition: safearray.c:600
HRESULT WINAPI PropVariantToBuffer(REFPROPVARIANT propvarIn, void *ret, UINT cb)
Definition: propvar.c:306
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLuint buffer
Definition: glext.h:5915
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PROTOCOLDATA * pdata
Definition: protocol.c:158

Referenced by START_TEST().

◆ test_PropVariantToDouble()

static void test_PropVariantToDouble ( void  )
static

Definition at line 1331 of file propsys.c.

1332{
1333 PROPVARIANT propvar;
1334 double value;
1335 HRESULT hr;
1336
1337 PropVariantInit(&propvar);
1338 propvar.vt = VT_R8;
1339 propvar.u.dblVal = 15.0;
1340 hr = PropVariantToDouble(&propvar, &value);
1341 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1342 ok(value == 15.0, "Unexpected value: %f.\n", value);
1343
1344 PropVariantClear(&propvar);
1345 propvar.vt = VT_I4;
1346 propvar.u.lVal = 123;
1347 hr = PropVariantToDouble(&propvar, &value);
1348 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1349 ok(value == 123.0, "Unexpected value: %f.\n", value);
1350
1351 PropVariantClear(&propvar);
1352 propvar.vt = VT_I4;
1353 propvar.u.lVal = -256;
1354 hr = PropVariantToDouble(&propvar, &value);
1355 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1356 ok(value == -256, "Unexpected value: %f\n", value);
1357
1358 PropVariantClear(&propvar);
1359 propvar.vt = VT_I8;
1360 propvar.u.lVal = 65536;
1361 hr = PropVariantToDouble(&propvar, &value);
1362 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1363 ok(value == 65536.0, "Unexpected value: %f.\n", value);
1364
1365 PropVariantClear(&propvar);
1366 propvar.vt = VT_I8;
1367 propvar.u.lVal = -321;
1368 hr = PropVariantToDouble(&propvar, &value);
1369 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1370 ok(value == 4294966975.0, "Unexpected value: %f.\n", value);
1371
1372 PropVariantClear(&propvar);
1373 propvar.vt = VT_UI4;
1374 propvar.u.ulVal = 6;
1375 hr = PropVariantToDouble(&propvar, &value);
1376 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1377 ok(value == 6.0, "Unexpected value: %f.\n", value);
1378
1379 PropVariantClear(&propvar);
1380 propvar.vt = VT_UI8;
1381 propvar.u.uhVal.QuadPart = 8;
1382 hr = PropVariantToDouble(&propvar, &value);
1383 ok(hr == S_OK, "PropVariantToDouble failed: 0x%08x.\n", hr);
1384 ok(value == 8.0, "Unexpected value: %f.\n", value);
1385}
HRESULT WINAPI PropVariantToDouble(REFPROPVARIANT propvarIn, double *ret)
Definition: propvar.c:162
Definition: pdh_main.c:94

Referenced by START_TEST().

◆ test_PropVariantToGUID()

static void test_PropVariantToGUID ( void  )
static

Definition at line 559 of file propsys.c.

560{
561 PROPVARIANT propvar;
562 VARIANT var;
563 GUID guid;
565
567 ok(hres == S_OK, "InitPropVariantFromGUIDAsString failed %x\n", hres);
568
569 hres = PropVariantToGUID(&propvar, &guid);
570 ok(hres == S_OK, "PropVariantToGUID failed %x\n", hres);
571 ok(IsEqualGUID(&IID_NULL, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
572 PropVariantClear(&propvar);
573
574 hres = InitPropVariantFromGUIDAsString(&dummy_guid, &propvar);
575 ok(hres == S_OK, "InitPropVariantFromGUIDAsString failed %x\n", hres);
576
577 hres = PropVariantToGUID(&propvar, &guid);
578 ok(hres == S_OK, "PropVariantToGUID failed %x\n", hres);
579 ok(IsEqualGUID(&dummy_guid, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
580
581 ok(propvar.vt == VT_LPWSTR, "incorrect PROPVARIANT type: %d\n", propvar.vt);
582 propvar.u.pwszVal[1] = 'd';
583 propvar.u.pwszVal[2] = 'E';
584 propvar.u.pwszVal[3] = 'a';
585 hres = PropVariantToGUID(&propvar, &guid);
586 ok(hres == S_OK, "PropVariantToGUID failed %x\n", hres);
587 ok(IsEqualGUID(&dummy_guid, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
588
589 propvar.u.pwszVal[1] = 'z';
590 hres = PropVariantToGUID(&propvar, &guid);
591 ok(hres == E_INVALIDARG, "PropVariantToGUID returned %x\n", hres);
592 PropVariantClear(&propvar);
593
594
596 ok(hres == S_OK, "InitVariantFromGUIDAsString failed %x\n", hres);
597
599 ok(hres == S_OK, "VariantToGUID failed %x\n", hres);
600 ok(IsEqualGUID(&IID_NULL, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
602
603 hres = InitVariantFromGUIDAsString(&dummy_guid, &var);
604 ok(hres == S_OK, "InitVariantFromGUIDAsString failed %x\n", hres);
605
607 ok(hres == S_OK, "VariantToGUID failed %x\n", hres);
608 ok(IsEqualGUID(&dummy_guid, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
609
610 ok(V_VT(&var) == VT_BSTR, "incorrect VARIANT type: %d\n", V_VT(&var));
611 V_BSTR(&var)[1] = 'z';
613 ok(hres == E_FAIL, "VariantToGUID returned %x\n", hres);
614
615 V_BSTR(&var)[1] = 'd';
616 propvar.vt = V_VT(&var);
617 propvar.u.bstrVal = V_BSTR(&var);
618 V_VT(&var) = VT_EMPTY;
619 hres = PropVariantToGUID(&propvar, &guid);
620 ok(hres == S_OK, "PropVariantToGUID failed %x\n", hres);
621 ok(IsEqualGUID(&dummy_guid, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
622 PropVariantClear(&propvar);
623
624 memset(&guid, 0, sizeof(guid));
625 InitPropVariantFromCLSID(&dummy_guid, &propvar);
626 hres = PropVariantToGUID(&propvar, &guid);
627 ok(hres == S_OK, "PropVariantToGUID failed %x\n", hres);
628 ok(IsEqualGUID(&dummy_guid, &guid), "incorrect GUID created: %s\n", wine_dbgstr_guid(&guid));
629 PropVariantClear(&propvar);
630}
HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
Definition: propvar.c:775
HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
Definition: propvar.c:756
static __inline const char * wine_dbgstr_guid(const GUID *id)
Definition: debug.h:197

Referenced by START_TEST().

◆ test_PropVariantToString()

static void test_PropVariantToString ( void  )
static

Definition at line 1387 of file propsys.c.

1388{
1389 PROPVARIANT propvar;
1390 static CHAR string[] = "Wine";
1391 static WCHAR stringW[] = {'W','i','n','e',0};
1392 WCHAR bufferW[256] = {0};
1393 HRESULT hr;
1394
1395 PropVariantInit(&propvar);
1396 propvar.vt = VT_EMPTY;
1397 U(propvar).pwszVal = stringW;
1398 bufferW[0] = 65;
1399 hr = PropVariantToString(&propvar, bufferW, 0);
1400 ok(hr == E_INVALIDARG, "PropVariantToString should fail: 0x%08x.\n", hr);
1401 ok(!bufferW[0], "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1402 memset(bufferW, 0, sizeof(bufferW));
1403 PropVariantClear(&propvar);
1404
1405 PropVariantInit(&propvar);
1406 propvar.vt = VT_EMPTY;
1407 U(propvar).pwszVal = stringW;
1408 bufferW[0] = 65;
1409 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1410 ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1411 ok(!bufferW[0], "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1412 memset(bufferW, 0, sizeof(bufferW));
1413 PropVariantClear(&propvar);
1414
1415 PropVariantInit(&propvar);
1416 propvar.vt = VT_NULL;
1417 U(propvar).pwszVal = stringW;
1418 bufferW[0] = 65;
1419 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1420 ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1421 ok(!bufferW[0], "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1422 memset(bufferW, 0, sizeof(bufferW));
1423 PropVariantClear(&propvar);
1424
1425 PropVariantInit(&propvar);
1426 propvar.vt = VT_I4;
1427 U(propvar).lVal = 22;
1428 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1429 todo_wine ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1430 todo_wine ok(!strcmp_wa(bufferW, "22"), "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1431 memset(bufferW, 0, sizeof(bufferW));
1432 PropVariantClear(&propvar);
1433
1434 PropVariantInit(&propvar);
1435 propvar.vt = VT_LPWSTR;
1436 U(propvar).pwszVal = stringW;
1437 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1438 ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1439 ok(!lstrcmpW(bufferW, stringW), "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1440 memset(bufferW, 0, sizeof(bufferW));
1441
1442 PropVariantInit(&propvar);
1443 propvar.vt = VT_LPSTR;
1444 U(propvar).pszVal = string;
1445 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1446 ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1447 ok(!lstrcmpW(bufferW, stringW), "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1448 memset(bufferW, 0, sizeof(bufferW));
1449
1450 PropVariantInit(&propvar);
1451 propvar.vt = VT_LPWSTR;
1452 U(propvar).pwszVal = stringW;
1453 hr = PropVariantToString(&propvar, bufferW, 4);
1454 ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "PropVariantToString returned: 0x%08x.\n", hr);
1455 ok(!memcmp(bufferW, stringW, 4), "got wrong string.\n");
1456 memset(bufferW, 0, sizeof(bufferW));
1457
1458 PropVariantInit(&propvar);
1459 propvar.vt = VT_LPSTR;
1460 U(propvar).pszVal = string;
1461 hr = PropVariantToString(&propvar, bufferW, 4);
1462 ok(hr == STRSAFE_E_INSUFFICIENT_BUFFER, "PropVariantToString returned: 0x%08x.\n", hr);
1463 ok(!memcmp(bufferW, stringW, 4), "got wrong string.\n");
1464 memset(bufferW, 0, sizeof(bufferW));
1465
1466 PropVariantInit(&propvar);
1467 propvar.vt = VT_BSTR;
1468 propvar.u.bstrVal = SysAllocString(stringW);
1469 hr = PropVariantToString(&propvar, bufferW, ARRAY_SIZE(bufferW));
1470 ok(hr == S_OK, "PropVariantToString failed: 0x%08x.\n", hr);
1471 ok(!lstrcmpW(bufferW, stringW), "got wrong string: \"%s\".\n", wine_dbgstr_w(bufferW));
1472 memset(bufferW, 0, sizeof(bufferW));
1473 SysFreeString(propvar.u.bstrVal);
1474}
HRESULT WINAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
Definition: propvar.c:332
static const WCHAR stringW[]
Definition: engine.c:38
char string[160]
Definition: util.h:11
#define STRSAFE_E_INSUFFICIENT_BUFFER
Definition: strsafe.h:103

Referenced by START_TEST().

◆ test_PropVariantToStringAlloc()

static void test_PropVariantToStringAlloc ( void  )
static

Definition at line 632 of file propsys.c.

633{
634 PROPVARIANT prop;
635 WCHAR *str;
637
638 prop.vt = VT_NULL;
640 ok(hres == S_OK, "returned %x\n", hres);
641 ok(!lstrcmpW(str, emptyW), "got %s\n", wine_dbgstr_w(str));
643
644 prop.vt = VT_LPSTR;
645 prop.u.pszVal = CoTaskMemAlloc(strlen(topic)+1);
646 strcpy(prop.u.pszVal, topic);
648 ok(hres == S_OK, "returned %x\n", hres);
649 ok(!lstrcmpW(str, topicW), "got %s\n", wine_dbgstr_w(str));
651 PropVariantClear(&prop);
652
653 prop.vt = VT_EMPTY;
655 ok(hres == S_OK, "returned %x\n", hres);
656 ok(!lstrcmpW(str, emptyW), "got %s\n", wine_dbgstr_w(str));
658}
HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
Definition: propvar.c:356

Referenced by START_TEST().

◆ test_PropVariantToStringWithDefault()

static void test_PropVariantToStringWithDefault ( void  )
static

Definition at line 1177 of file propsys.c.

1178{
1179 PROPVARIANT propvar;
1180 static WCHAR default_value[] = {'t', 'e', 's', 't', 0};
1181 static WCHAR wstr_test2[] = {'t', 'e', 's', 't', '2', 0};
1182 static WCHAR wstr_empty[] = {0};
1183 static WCHAR wstr_space[] = {' ', 0};
1184 static CHAR str_test2[] = "test2";
1185 static CHAR str_empty[] = "";
1186 static CHAR str_space[] = " ";
1188
1189 propvar.vt = VT_EMPTY;
1190 result = PropVariantToStringWithDefault(&propvar, default_value);
1191 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1192
1193 propvar.vt = VT_NULL;
1194 result = PropVariantToStringWithDefault(&propvar, default_value);
1195 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1196
1197 propvar.vt = VT_BOOL;
1198 propvar.u.boolVal = VARIANT_TRUE;
1199 result = PropVariantToStringWithDefault(&propvar, default_value);
1200 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1201
1202 propvar.vt = VT_I4;
1203 propvar.u.lVal = 15;
1204 result = PropVariantToStringWithDefault(&propvar, default_value);
1205 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1206
1207 /* VT_LPWSTR */
1208
1209 propvar.vt = VT_LPWSTR;
1210 propvar.u.pwszVal = NULL;
1211 result = PropVariantToStringWithDefault(&propvar, default_value);
1212 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1213
1214 propvar.vt = VT_LPWSTR;
1215 propvar.u.pwszVal = wstr_empty;
1216 result = PropVariantToStringWithDefault(&propvar, default_value);
1217 ok(result == wstr_empty, "Unexpected value %s\n", wine_dbgstr_w(result));
1218
1219 propvar.vt = VT_LPWSTR;
1220 propvar.u.pwszVal = wstr_space;
1221 result = PropVariantToStringWithDefault(&propvar, default_value);
1222 ok(result == wstr_space, "Unexpected value %s\n", wine_dbgstr_w(result));
1223
1224 propvar.vt = VT_LPWSTR;
1225 propvar.u.pwszVal = wstr_test2;
1226 result = PropVariantToStringWithDefault(&propvar, default_value);
1227 ok(result == wstr_test2, "Unexpected value %s\n", wine_dbgstr_w(result));
1228
1229 /* VT_LPSTR */
1230
1231 propvar.vt = VT_LPSTR;
1232 propvar.u.pszVal = NULL;
1233 result = PropVariantToStringWithDefault(&propvar, default_value);
1234 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1235
1236 propvar.vt = VT_LPSTR;
1237 propvar.u.pszVal = str_empty;
1238 result = PropVariantToStringWithDefault(&propvar, default_value);
1239 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1240
1241 propvar.vt = VT_LPSTR;
1242 propvar.u.pszVal = str_space;
1243 result = PropVariantToStringWithDefault(&propvar, default_value);
1244 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1245
1246 propvar.vt = VT_LPSTR;
1247 propvar.u.pszVal = str_test2;
1248 result = PropVariantToStringWithDefault(&propvar, default_value);
1249 ok(result == default_value, "Unexpected value %s\n", wine_dbgstr_w(result));
1250
1251 /* VT_BSTR */
1252
1253 propvar.vt = VT_BSTR;
1254 propvar.u.bstrVal = NULL;
1255 result = PropVariantToStringWithDefault(&propvar, default_value);
1256 ok(!lstrcmpW(result, wstr_empty), "Unexpected value %s\n", wine_dbgstr_w(result));
1257
1258 propvar.vt = VT_BSTR;
1259 propvar.u.bstrVal = SysAllocString(wstr_empty);
1260 result = PropVariantToStringWithDefault(&propvar, default_value);
1261 ok(!lstrcmpW(result, wstr_empty), "Unexpected value %s\n", wine_dbgstr_w(result));
1262 SysFreeString(propvar.u.bstrVal);
1263
1264 propvar.vt = VT_BSTR;
1265 propvar.u.bstrVal = SysAllocString(wstr_space);
1266 result = PropVariantToStringWithDefault(&propvar, default_value);
1267 ok(!lstrcmpW(result, wstr_space), "Unexpected value %s\n", wine_dbgstr_w(result));
1268 SysFreeString(propvar.u.bstrVal);
1269
1270 propvar.vt = VT_BSTR;
1271 propvar.u.bstrVal = SysAllocString(wstr_test2);
1272 result = PropVariantToStringWithDefault(&propvar, default_value);
1273 ok(!lstrcmpW(result, wstr_test2), "Unexpected value %s\n", wine_dbgstr_w(result));
1274 SysFreeString(propvar.u.bstrVal);
1275}
PCWSTR WINAPI PropVariantToStringWithDefault(REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
Definition: propvar.c:407
GLuint64EXT * result
Definition: glext.h:11304
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by START_TEST().

◆ test_PSPropertyKeyFromString()

static void test_PSPropertyKeyFromString ( void  )
static

Definition at line 158 of file propsys.c.

159{
160 static const WCHAR fmtid_clsidW[] = {'S','t','d','F','o','n','t',' ','1',0};
161 static const WCHAR fmtid_truncatedW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
162 '1','2','3','4','-',0};
163 static const WCHAR fmtid_nobracketsW[] = {'1','2','3','4','5','6','7','8','-','1','2','3','4','-',
164 '1','2','3','4','-','1','2','3','4','-',
165 '1','2','3','4','5','6','7','8','9','0','1','2',0};
166 static const WCHAR fmtid_badbracketW[] = {'X','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
167 '1','2','3','4','-','1','2','3','4','-',
168 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
169 static const WCHAR fmtid_badcharW[] = {'{','X','2','3','4','5','6','7','8','-','1','2','3','4','-',
170 '1','2','3','4','-','1','2','3','4','-',
171 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
172 static const WCHAR fmtid_badchar2W[] = {'{','1','2','3','4','5','6','7','X','-','1','2','3','4','-',
173 '1','2','3','4','-','1','2','3','4','-',
174 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
175 static const WCHAR fmtid_baddashW[] = {'{','1','2','3','4','5','6','7','8','X','1','2','3','4','-',
176 '1','2','3','4','-','1','2','3','4','-',
177 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
178 static const WCHAR fmtid_badchar3W[] = {'{','1','2','3','4','5','6','7','8','-','X','2','3','4','-',
179 '1','2','3','4','-','1','2','3','4','-',
180 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
181 static const WCHAR fmtid_badchar4W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','X','-',
182 '1','2','3','4','-','1','2','3','4','-',
183 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
184 static const WCHAR fmtid_baddash2W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','X',
185 '1','2','3','4','-','1','2','3','4','-',
186 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
187 static const WCHAR fmtid_badchar5W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
188 'X','2','3','4','-','1','2','3','4','-',
189 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
190 static const WCHAR fmtid_badchar6W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
191 '1','2','3','X','-','1','2','3','4','-',
192 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
193 static const WCHAR fmtid_baddash3W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
194 '1','2','3','4','X','1','2','3','4','-',
195 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
196 static const WCHAR fmtid_badchar7W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
197 '1','2','3','4','-','X','2','3','4','-',
198 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
199 static const WCHAR fmtid_badchar8W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
200 '1','2','3','4','-','1','2','3','X','-',
201 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
202 static const WCHAR fmtid_baddash4W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
203 '1','2','3','4','-','1','2','3','4','X',
204 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
205 static const WCHAR fmtid_badchar9W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
206 '1','2','3','4','-','1','2','3','4','-',
207 'X','2','3','4','5','6','7','8','9','0','1','2','}',0};
208 static const WCHAR fmtid_badchar9_adjW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
209 '1','2','3','4','-','1','2','3','4','-',
210 '1','X','3','4','5','6','7','8','9','0','1','2','}',0};
211 static const WCHAR fmtid_badchar10W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
212 '1','2','3','4','-','1','2','3','4','-',
213 '1','2','X','4','5','6','7','8','9','0','1','2','}',0};
214 static const WCHAR fmtid_badchar11W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
215 '1','2','3','4','-','1','2','3','4','-',
216 '1','2','3','4','X','6','7','8','9','0','1','2','}',0};
217 static const WCHAR fmtid_badchar12W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
218 '1','2','3','4','-','1','2','3','4','-',
219 '1','2','3','4','5','6','X','8','9','0','1','2','}',0};
220 static const WCHAR fmtid_badchar13W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
221 '1','2','3','4','-','1','2','3','4','-',
222 '1','2','3','4','5','6','7','8','X','0','1','2','}',0};
223 static const WCHAR fmtid_badchar14W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
224 '1','2','3','4','-','1','2','3','4','-',
225 '1','2','3','4','5','6','7','8','9','0','X','2','}',0};
226 static const WCHAR fmtid_badbracket2W[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
227 '1','2','3','4','-','1','2','3','4','-',
228 '1','2','3','4','5','6','7','8','9','0','1','2','X',0};
229 static const WCHAR fmtid_spaceW[] = {' ','{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
230 '1','2','3','4','-','1','2','3','4','-',
231 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
232 static const WCHAR fmtid_spaceendW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
233 '1','2','3','4','-','1','2','3','4','-',
234 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',0};
235 static const WCHAR fmtid_spacesendW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
236 '1','2','3','4','-','1','2','3','4','-',
237 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',' ',' ',0};
238 static const WCHAR fmtid_nopidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
239 '1','2','3','4','-','1','2','3','4','-',
240 '1','2','3','4','5','6','7','8','9','0','1','2','}',0};
241 static const WCHAR fmtid_badpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
242 '1','2','3','4','-','1','2','3','4','-',
243 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','D','E','A','D',0};
244 static const WCHAR fmtid_adjpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
245 '1','2','3','4','-','1','2','3','4','-',
246 '1','2','3','4','5','6','7','8','9','0','1','2','}','1','3','5','7','9',0};
247 static const WCHAR fmtid_spacespidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
248 '1','2','3','4','-','1','2','3','4','-',
249 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',' ',' ','1','3','5','7','9',0};
250 static const WCHAR fmtid_negpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
251 '1','2','3','4','-','1','2','3','4','-',
252 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-','1','3','5','7','9',0};
253 static const WCHAR fmtid_negnegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
254 '1','2','3','4','-','1','2','3','4','-',
255 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-','-','1','3','5','7','9',0};
256 static const WCHAR fmtid_negnegnegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
257 '1','2','3','4','-','1','2','3','4','-',
258 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-','-','-','1','3','5','7','9',0};
259 static const WCHAR fmtid_negspacepidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
260 '1','2','3','4','-','1','2','3','4','-',
261 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-',' ','1','3','5','7','9',0};
262 static const WCHAR fmtid_negspacenegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
263 '1','2','3','4','-','1','2','3','4','-',
264 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-',' ','-','1','3','5','7','9',0};
265 static const WCHAR fmtid_negspacespidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
266 '1','2','3','4','-','1','2','3','4','-',
267 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','-',' ','-',' ','-','1','3','5','7','9',0};
268 static const WCHAR fmtid_pospidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
269 '1','2','3','4','-','1','2','3','4','-',
270 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','+','1','3','5','7','9',0};
271 static const WCHAR fmtid_posnegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
272 '1','2','3','4','-','1','2','3','4','-',
273 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','+','-','+','-','1','3','5','7','9',0};
274 static const WCHAR fmtid_symbolpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
275 '1','2','3','4','-','1','2','3','4','-',
276 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','+','/','$','-','1','3','5','7','9',0};
277 static const WCHAR fmtid_letterpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
278 '1','2','3','4','-','1','2','3','4','-',
279 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','A','B','C','D','1','3','5','7','9',0};
280 static const WCHAR fmtid_spacepadpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
281 '1','2','3','4','-','1','2','3','4','-',
282 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','1','3','5','7','9',' ',' ',' ',0};
283 static const WCHAR fmtid_spacemixpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
284 '1','2','3','4','-','1','2','3','4','-',
285 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','1',' ','3',' ','5','7','9',' ',' ',' ',0};
286 static const WCHAR fmtid_tabpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
287 '1','2','3','4','-','1','2','3','4','-',
288 '1','2','3','4','5','6','7','8','9','0','1','2','}','\t','1','3','5','7','9',0};
289 static const WCHAR fmtid_hexpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
290 '1','2','3','4','-','1','2','3','4','-',
291 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','0','x','D','E','A','D',0};
292 static const WCHAR fmtid_mixedpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
293 '1','2','3','4','-','1','2','3','4','-',
294 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','A','9','B','5','C','3','D','1',0};
295 static const WCHAR fmtid_overflowpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
296 '1','2','3','4','-','1','2','3','4','-',
297 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','1','2','3','4','5','6','7','8','9','0','1',0};
298 static const WCHAR fmtid_commapidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
299 '1','2','3','4','-','1','2','3','4','-',
300 '1','2','3','4','5','6','7','8','9','0','1','2','}',',','1','3','5','7','9',0};
301 static const WCHAR fmtid_commaspidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
302 '1','2','3','4','-','1','2','3','4','-',
303 '1','2','3','4','5','6','7','8','9','0','1','2','}',',',',',',','1','3','5','7','9',0};
304 static const WCHAR fmtid_commaspacepidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
305 '1','2','3','4','-','1','2','3','4','-',
306 '1','2','3','4','5','6','7','8','9','0','1','2','}',',',' ','1','3','5','7','9',0};
307 static const WCHAR fmtid_spacecommapidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
308 '1','2','3','4','-','1','2','3','4','-',
309 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',',','1','3','5','7','9',0};
310 static const WCHAR fmtid_spccommaspcpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
311 '1','2','3','4','-','1','2','3','4','-',
312 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',',',' ','1','3','5','7','9',0};
313 static const WCHAR fmtid_spacescommaspidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
314 '1','2','3','4','-','1','2','3','4','-',
315 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',',',' ',',','1','3','5','7','9',0};
316 static const WCHAR fmtid_commanegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
317 '1','2','3','4','-','1','2','3','4','-',
318 '1','2','3','4','5','6','7','8','9','0','1','2','}',',','-','1','3','5','7','9',0};
319 static const WCHAR fmtid_spccommanegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
320 '1','2','3','4','-','1','2','3','4','-',
321 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',',','-','1','3','5','7','9',0};
322 static const WCHAR fmtid_commaspcnegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
323 '1','2','3','4','-','1','2','3','4','-',
324 '1','2','3','4','5','6','7','8','9','0','1','2','}',',',' ','-','1','3','5','7','9',0};
325 static const WCHAR fmtid_spccommaspcnegpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
326 '1','2','3','4','-','1','2','3','4','-',
327 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ',',',' ','-','1','3','5','7','9',0};
328 static const WCHAR fmtid_commanegspcpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
329 '1','2','3','4','-','1','2','3','4','-',
330 '1','2','3','4','5','6','7','8','9','0','1','2','}',',','-',' ','1','3','5','7','9',0};
331 static const WCHAR fmtid_negcommapidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
332 '1','2','3','4','-','1','2','3','4','-',
333 '1','2','3','4','5','6','7','8','9','0','1','2','}','-',',','1','3','5','7','9',0};
334 static const WCHAR fmtid_normalpidW[] = {'{','1','2','3','4','5','6','7','8','-','1','2','3','4','-',
335 '1','2','3','4','-','1','2','3','4','-',
336 '1','2','3','4','5','6','7','8','9','0','1','2','}',' ','1','3','5','7','9',0};
337 PROPERTYKEY out_init = {GUID_MEMBERS(dummy_guid), 0xdeadbeef};
338 PROPERTYKEY out;
339 HRESULT ret;
340
341 const struct
342 {
343 LPCWSTR pwzString;
344 PROPERTYKEY *pkey;
345 HRESULT hr_expect;
346 PROPERTYKEY pkey_expect;
347 } testcases[] =
348 {
349 {NULL, NULL, E_POINTER},
350 {NULL, &out, E_POINTER, {GUID_MEMBERS(out_init.fmtid), out_init.pid}},
353 {fmtid_clsidW, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0}},
354 {fmtid_truncatedW, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0,0,0,0,0,0,0,0}}, 0}},
355 {fmtid_nobracketsW, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0}},
356 {fmtid_badbracketW, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0}},
357 {fmtid_badcharW, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0}},
358 {fmtid_badchar2W, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0}},
359 {fmtid_baddashW, &out, E_INVALIDARG, { {0x12345678,0,0,{0,0,0,0,0,0,0,0}}, 0}},
360 {fmtid_badchar3W, &out, E_INVALIDARG, { {0x12345678,0,0,{0,0,0,0,0,0,0,0}}, 0}},
361 {fmtid_badchar4W, &out, E_INVALIDARG, { {0x12345678,0,0,{0,0,0,0,0,0,0,0}}, 0}},
362 {fmtid_baddash2W, &out, E_INVALIDARG, { {0x12345678,0,0,{0,0,0,0,0,0,0,0}}, 0}},
363 {fmtid_badchar5W, &out, E_INVALIDARG, { {0x12345678,0x1234,0,{0,0,0,0,0,0,0,0}}, 0}},
364 {fmtid_badchar6W, &out, E_INVALIDARG, { {0x12345678,0x1234,0,{0,0,0,0,0,0,0,0}}, 0}},
365 {fmtid_baddash3W, &out, E_INVALIDARG, { {0x12345678,0x1234,0,{0,0,0,0,0,0,0,0}}, 0}},
366 {fmtid_badchar7W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0,0,0,0,0,0,0,0}}, 0}},
367 {fmtid_badchar8W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0,0,0,0,0,0,0}}, 0}},
368 {fmtid_baddash4W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0,0,0,0,0,0,0}}, 0}},
369 {fmtid_badchar9W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0,0,0,0,0,0}}, 0}},
370 {fmtid_badchar9_adjW, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0,0,0,0,0,0}}, 0}},
371 {fmtid_badchar10W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0,0,0,0,0}}, 0}},
372 {fmtid_badchar11W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0x34,0,0,0,0}}, 0}},
373 {fmtid_badchar12W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0x34,0x56,0,0,0}}, 0}},
374 {fmtid_badchar13W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0x34,0x56,0x78,0,0}}, 0}},
375 {fmtid_badchar14W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0x34,0x56,0x78,0x90,0}}, 0}},
376 {fmtid_badbracket2W, &out, E_INVALIDARG, { {0x12345678,0x1234,0x1234,{0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x00}}, 0 }},
377 {fmtid_spaceW, &out, E_INVALIDARG, {GUID_MEMBERS(GUID_NULL), 0 }},
378 {fmtid_spaceendW, &out, E_INVALIDARG, {GUID_MEMBERS(expect_guid), 0}},
379 {fmtid_spacesendW, &out, E_INVALIDARG, {GUID_MEMBERS(expect_guid), 0}},
380 {fmtid_nopidW, &out, E_INVALIDARG, {GUID_MEMBERS(expect_guid), 0}},
381 {fmtid_badpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
382 {fmtid_adjpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
383 {fmtid_spacespidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
384 {fmtid_negpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
385 {fmtid_negnegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
386 {fmtid_negnegnegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
387 {fmtid_negspacepidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
388 {fmtid_negspacenegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
389 {fmtid_negspacespidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
390 {fmtid_pospidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
391 {fmtid_posnegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
392 {fmtid_symbolpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
393 {fmtid_letterpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
394 {fmtid_spacepadpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
395 {fmtid_spacemixpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 1}},
396 {fmtid_tabpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
397 {fmtid_hexpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
398 {fmtid_mixedpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
399 {fmtid_overflowpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 3755744309U}},
400 {fmtid_commapidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
401 {fmtid_commaspidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
402 {fmtid_commaspacepidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
403 {fmtid_spacecommapidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
404 {fmtid_spccommaspcpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
405 {fmtid_spacescommaspidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
406 {fmtid_commanegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
407 {fmtid_spccommanegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
408 {fmtid_commaspcnegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
409 {fmtid_spccommaspcnegpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 4294953717U}},
410 {fmtid_commanegspcpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0U}},
411 {fmtid_negcommapidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 0}},
412 {fmtid_normalpidW, &out, S_OK, {GUID_MEMBERS(expect_guid), 13579}},
413 };
414
415 int i;
416
417 for (i = 0; i < ARRAY_SIZE(testcases); i++)
418 {
419 if (testcases[i].pkey)
420 *testcases[i].pkey = out_init;
421
422 ret = PSPropertyKeyFromString(testcases[i].pwzString, testcases[i].pkey);
423 ok(ret == testcases[i].hr_expect,
424 "[%d] Expected PSPropertyKeyFromString to return 0x%08x, got 0x%08x\n",
425 i, testcases[i].hr_expect, ret);
426
427 if (testcases[i].pkey)
428 {
429 ok(IsEqualGUID(&testcases[i].pkey->fmtid, &testcases[i].pkey_expect.fmtid),
430 "[%d] Expected GUID %s, got %s\n",
431 i, wine_dbgstr_guid(&testcases[i].pkey_expect.fmtid), wine_dbgstr_guid(&testcases[i].pkey->fmtid));
432 ok(testcases[i].pkey->pid == testcases[i].pkey_expect.pid,
433 "[%d] Expected property ID %u, got %u\n",
434 i, testcases[i].pkey_expect.pid, testcases[i].pkey->pid);
435 }
436 }
437}
#define expect_guid(expected, guid)
Definition: typelib.c:49
#define GUID_MEMBERS(g)
Definition: propsys.c:42
HRESULT WINAPI PSPropertyKeyFromString(LPCWSTR pszString, PROPERTYKEY *pkey)
Definition: propsys_main.c:432
static FILE * out
Definition: regtests2xml.c:44
int ret
#define E_POINTER
Definition: winerror.h:2365

Referenced by START_TEST().

◆ test_PSRefreshPropertySchema()

static void test_PSRefreshPropertySchema ( void  )
static

Definition at line 439 of file propsys.c.

440{
441 HRESULT ret;
442
446 "Expected PSRefreshPropertySchema to return CO_E_NOTINITIALIZED, got 0x%08x\n", ret);
447
449
451 ok(ret == S_OK,
452 "Expected PSRefreshPropertySchema to return S_OK, got 0x%08x\n", ret);
453
455}
#define CO_E_NOTINITIALIZED
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
HRESULT WINAPI PSRefreshPropertySchema(void)
Definition: propsys_main.c:278

Referenced by START_TEST().

◆ test_PSStringFromPropertyKey()

static void test_PSStringFromPropertyKey ( void  )
static

Definition at line 55 of file propsys.c.

56{
57 static const WCHAR fillerW[] = {'X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X',
58 'X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X',
59 'X','X','X','X','X','X','X','X','X','X'};
60 static const WCHAR zero_fillerW[] = {'\0','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X',
61 'X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X','X',
62 'X','X','X','X','X','X','X','X','X','X','X','X','X','X'};
63 static const WCHAR zero_truncatedW[] = {'\0','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0',
64 '0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0',
65 '0','0','0','}',' ','\0','9','X','X','X','X','X','X','X','X','X'};
66 static const WCHAR zero_truncated2W[] = {'\0','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0',
67 '0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0',
68 '0','0','0','}',' ','\0','9','2','7','6','9','4','9','2','X','X'};
69 static const WCHAR zero_truncated3W[] = {'\0','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0',
70 '0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0',
71 '0','0','0','}',' ','\0','9','2','7','6','9','4','9','2','4','X'};
72 static const WCHAR zero_truncated4W[] = {'\0','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0',
73 '0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0',
74 '0','0','0','}',' ','\0','7','X','X','X','X','X','X','X','X','X'};
75 static const WCHAR truncatedW[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
76 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
77 '0','}',' ','\0','9','X','X','X','X','X','X','X','X','X'};
78 static const WCHAR truncated2W[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
79 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
80 '0','}',' ','\0','9','2','7','6','9','4','9','2','X','X'};
81 static const WCHAR truncated3W[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
82 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
83 '0','}',' ','\0','9','2','7','6','9','4','9','2','4','X'};
84 static const WCHAR truncated4W[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
85 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
86 '0','}',' ','\0','7','X','X','X','X','X','X','X','X','X'};
87 static const WCHAR expectedW[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
88 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
89 '0','}',' ','4','2','9','4','9','6','7','2','9','5',0};
90 static const WCHAR expected2W[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
91 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
92 '0','}',' ','1','3','5','7','9','\0','X','X','X','X','X'};
93 static const WCHAR expected3W[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-','0','0','0',
94 '0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0',
95 '0','}',' ','0','\0','X','X','X','X','X','X','X','X','X'};
96 PROPERTYKEY prop = {GUID_MEMBERS(GUID_NULL), ~0U};
97 PROPERTYKEY prop2 = {GUID_MEMBERS(GUID_NULL), 13579};
98 PROPERTYKEY prop3 = {GUID_MEMBERS(GUID_NULL), 0};
99 WCHAR out[PKEYSTR_MAX];
100 HRESULT ret;
101
102 const struct
103 {
104 REFPROPERTYKEY pkey;
105 LPWSTR psz;
106 UINT cch;
107 HRESULT hr_expect;
108 const WCHAR *buf_expect;
109 BOOL hr_broken;
110 HRESULT hr2;
111 BOOL buf_broken;
112 const WCHAR *buf2;
113 } testcases[] =
114 {
115 {NULL, NULL, 0, E_POINTER},
116 {&prop, NULL, 0, E_POINTER},
117 {&prop, NULL, PKEYSTR_MAX, E_POINTER},
118 {NULL, out, 0, E_NOT_SUFFICIENT_BUFFER, fillerW},
119 {NULL, out, PKEYSTR_MAX, E_NOT_SUFFICIENT_BUFFER, zero_fillerW, FALSE, 0, TRUE, fillerW},
120 {&prop, out, 0, E_NOT_SUFFICIENT_BUFFER, fillerW},
121 {&prop, out, GUIDSTRING_MAX, E_NOT_SUFFICIENT_BUFFER, fillerW},
122 {&prop, out, GUIDSTRING_MAX + 1, E_NOT_SUFFICIENT_BUFFER, fillerW},
123 {&prop, out, GUIDSTRING_MAX + 2, E_NOT_SUFFICIENT_BUFFER, zero_truncatedW, TRUE, S_OK, TRUE, truncatedW},
124 {&prop, out, PKEYSTR_MAX - 2, E_NOT_SUFFICIENT_BUFFER, zero_truncated2W, TRUE, S_OK, TRUE, truncated2W},
125 {&prop, out, PKEYSTR_MAX - 1, E_NOT_SUFFICIENT_BUFFER, zero_truncated3W, TRUE, S_OK, TRUE, truncated3W},
126 {&prop, out, PKEYSTR_MAX, S_OK, expectedW},
127 {&prop2, out, GUIDSTRING_MAX + 2, E_NOT_SUFFICIENT_BUFFER, zero_truncated4W, TRUE, S_OK, TRUE, truncated4W},
128 {&prop2, out, GUIDSTRING_MAX + 6, S_OK, expected2W},
129 {&prop2, out, PKEYSTR_MAX, S_OK, expected2W},
130 {&prop3, out, GUIDSTRING_MAX + 1, E_NOT_SUFFICIENT_BUFFER, fillerW},
131 {&prop3, out, GUIDSTRING_MAX + 2, S_OK, expected3W},
132 {&prop3, out, PKEYSTR_MAX, S_OK, expected3W},
133 };
134
135 int i;
136
137 for (i = 0; i < ARRAY_SIZE(testcases); i++)
138 {
139 if (testcases[i].psz)
140 memcpy(testcases[i].psz, fillerW, PKEYSTR_MAX * sizeof(WCHAR));
141
142 ret = PSStringFromPropertyKey(testcases[i].pkey,
143 testcases[i].psz,
144 testcases[i].cch);
145 ok(ret == testcases[i].hr_expect ||
146 broken(testcases[i].hr_broken && ret == testcases[i].hr2), /* Vista/Win2k8 */
147 "[%d] Expected PSStringFromPropertyKey to return 0x%08x, got 0x%08x\n",
148 i, testcases[i].hr_expect, ret);
149
150 if (testcases[i].psz)
151 ok(!memcmp(testcases[i].psz, testcases[i].buf_expect, PKEYSTR_MAX * sizeof(WCHAR)) ||
152 broken(testcases[i].buf_broken &&
153 !memcmp(testcases[i].psz, testcases[i].buf2, PKEYSTR_MAX * sizeof(WCHAR))), /* Vista/Win2k8 */
154 "[%d] Unexpected output contents\n", i);
155 }
156}
#define broken(x)
Definition: _sntprintf.h:21
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
unsigned int UINT
Definition: ndis.h:50
PROPERTYKEY * REFPROPERTYKEY
Definition: propsys.idl:34
HRESULT WINAPI PSStringFromPropertyKey(REFPROPERTYKEY pkey, LPWSTR psz, UINT cch)
Definition: propsys_main.c:284
#define E_NOT_SUFFICIENT_BUFFER
Definition: winerror.h:2345
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by START_TEST().

Variable Documentation

◆ emptyW

const WCHAR emptyW[] = {0}
static

◆ topic

◆ topicW

const WCHAR topicW[] = {'w','i','n','e',' ','t','o','p','i','c',0}
static