ReactOS  0.4.15-dev-318-g99b52df
CComVariant.cpp File Reference
#include <apitest.h>
#include <atlbase.h>
#include <versionhelpers.h>
Include dependency graph for CComVariant.cpp:

Go to the source code of this file.

Macros

#define ATLASSERT(x)
 
#define _ATL_NO_VARIANT_THROW
 
#define expect_bool   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_bool_imp
 
#define expect_int   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_int_imp
 
#define expect_uint   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_uint_imp
 
#define expect_double   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_double_imp
 
#define expect_error   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_error_imp
 
#define expect_empty   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_empty_imp
 

Functions

void expect_bool_imp (const CComVariant &ccv, bool value)
 
void expect_int_imp (const CComVariant &ccv, int value, unsigned short type)
 
void expect_uint_imp (const CComVariant &ccv, unsigned int value, unsigned short type)
 
void expect_double_imp (const CComVariant &ccv, double value, unsigned short type)
 
void expect_error_imp (const CComVariant &ccv, SCODE value)
 
void expect_empty_imp (const CComVariant &ccv)
 
static void test_construction ()
 
static void test_copyconstructor ()
 
static void test_assign ()
 
static void test_misc ()
 
 START_TEST (CComVariant)
 

Macro Definition Documentation

◆ _ATL_NO_VARIANT_THROW

#define _ATL_NO_VARIANT_THROW

Definition at line 11 of file CComVariant.cpp.

◆ ATLASSERT

#define ATLASSERT (   x)

Definition at line 10 of file CComVariant.cpp.

◆ expect_bool

#define expect_bool   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_bool_imp

Definition at line 55 of file CComVariant.cpp.

◆ expect_double

#define expect_double   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_double_imp

Definition at line 58 of file CComVariant.cpp.

◆ expect_empty

#define expect_empty   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_empty_imp

Definition at line 60 of file CComVariant.cpp.

◆ expect_error

#define expect_error   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_error_imp

Definition at line 59 of file CComVariant.cpp.

◆ expect_int

#define expect_int   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_int_imp

Definition at line 56 of file CComVariant.cpp.

◆ expect_uint

#define expect_uint   (winetest_set_location(__FILE__, __LINE__), 0) ? (void)0 : expect_uint_imp

Definition at line 57 of file CComVariant.cpp.

Function Documentation

◆ expect_bool_imp()

void expect_bool_imp ( const CComVariant &  ccv,
bool  value 
)

Definition at line 17 of file CComVariant.cpp.

18 {
19  winetest_ok(V_VT(&ccv) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&ccv));
20  VARIANT_BOOL expected = (value ? VARIANT_TRUE : VARIANT_FALSE);
21  winetest_ok(V_BOOL(&ccv) == expected, "Expected value to be %u, was: %u\n", expected, V_BOOL(&ccv));
22 }
short VARIANT_BOOL
Definition: compat.h:1940
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define V_BOOL(A)
Definition: oleauto.h:224
#define V_VT(A)
Definition: oleauto.h:211
BOOL expected
Definition: store.c:2063

◆ expect_double_imp()

void expect_double_imp ( const CComVariant &  ccv,
double  value,
unsigned short  type 
)

Definition at line 36 of file CComVariant.cpp.

37 {
38  winetest_ok(V_VT(&ccv) == type, "Expected .vt to be %u, was %u\n", type, V_VT(&ccv));
39  winetest_ok(V_R8(&ccv) == value, "Expected value to be %f, was: %f\n", value, V_R8(&ccv));
40 }
#define V_R8(A)
Definition: oleauto.h:262
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define V_VT(A)
Definition: oleauto.h:211

◆ expect_empty_imp()

void expect_empty_imp ( const CComVariant &  ccv)

Definition at line 48 of file CComVariant.cpp.

49 {
50  winetest_ok(V_VT(&ccv) == VT_EMPTY, "Expected .vt to be VT_EMPTY, was %u\n", V_VT(&ccv));
51  if (IsWindows8OrGreater())
52  winetest_ok(V_I8(&ccv) == 0ll, "Expected value to be 0, was: %I64d\n", V_I8(&ccv));
53 }
#define V_I8(A)
Definition: oleauto.h:249
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
VERSIONHELPERAPI IsWindows8OrGreater()
#define V_VT(A)
Definition: oleauto.h:211
w ll
Definition: byte_order.h:166

◆ expect_error_imp()

void expect_error_imp ( const CComVariant &  ccv,
SCODE  value 
)

Definition at line 42 of file CComVariant.cpp.

43 {
44  winetest_ok(V_VT(&ccv) == VT_ERROR, "Expected .vt to be VT_ERROR, was %u\n", V_VT(&ccv));
45  winetest_ok(V_ERROR(&ccv) == value, "Expected value to be %lx, was: %lx\n", value, V_ERROR(&ccv));
46 }
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define V_VT(A)
Definition: oleauto.h:211
#define V_ERROR(A)
Definition: oleauto.h:241

◆ expect_int_imp()

void expect_int_imp ( const CComVariant &  ccv,
int  value,
unsigned short  type 
)

Definition at line 24 of file CComVariant.cpp.

25 {
26  winetest_ok(V_VT(&ccv) == type, "Expected .vt to be %u, was %u\n", type, V_VT(&ccv));
27  winetest_ok(V_I4(&ccv) == value, "Expected value to be %d, was: %ld\n", value, V_I4(&ccv));
28 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define V_I4(A)
Definition: oleauto.h:247
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define V_VT(A)
Definition: oleauto.h:211

◆ expect_uint_imp()

void expect_uint_imp ( const CComVariant &  ccv,
unsigned int  value,
unsigned short  type 
)

Definition at line 30 of file CComVariant.cpp.

31 {
32  winetest_ok(V_VT(&ccv) == type, "Expected .vt to be %u, was %u\n", type, V_VT(&ccv));
33  winetest_ok(V_UI4(&ccv) == value, "Expected value to be %u, was: %lu\n", value, V_UI4(&ccv));
34 }
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
void __winetest_cdecl winetest_ok(int condition, const char *msg,...)
#define V_UI4(A)
Definition: oleauto.h:270
#define V_VT(A)
Definition: oleauto.h:211

◆ START_TEST()

START_TEST ( CComVariant  )

Definition at line 468 of file CComVariant.cpp.

469 {
472  test_assign();
473  test_misc();
474 }
static void test_construction()
Definition: CComVariant.cpp:63
static void test_copyconstructor()
static void test_assign()
static void test_misc()

◆ test_assign()

static void test_assign ( )
static

Definition at line 271 of file CComVariant.cpp.

272 {
273  {
274  CComVariant empty;
275  CComVariant empty2 = empty;
276  expect_empty(empty2);
277  }
278  {
279  CComBSTR bstr(L"TESTW");
280  CComVariant olestr = (LPCOLESTR)bstr;
281  ok(V_VT(&olestr) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&olestr));
282  ok(!wcscmp(V_BSTR(&olestr), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&olestr)));
283  CComVariant olestr2 = olestr;
284  ok(V_VT(&olestr2) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&olestr2));
285  ok(!wcscmp(V_BSTR(&olestr2), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&olestr2)));
286  }
287  {
288  CComVariant trueVal = true;
289  ok(V_VT(&trueVal) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&trueVal));
290  ok(V_BOOL(&trueVal) == VARIANT_TRUE, "Expected value to be VARIANT_TRUE, was: %u\n", V_BOOL(&trueVal));
291  CComVariant trueVal2 = trueVal;
292  ok(V_VT(&trueVal2) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&trueVal2));
293  ok(V_BOOL(&trueVal2) == VARIANT_TRUE, "Expected value to be VARIANT_TRUE, was: %u\n", V_BOOL(&trueVal2));
294  }
295  {
296  CComVariant b1 = (BYTE)33;
297  ok(V_VT(&b1) == VT_UI1, "Expected .vt to be VT_UI1, was %u\n", V_VT(&b1));
298  ok(V_UI1(&b1) == (BYTE)33, "Expected value to be 33, was: %u\n", V_UI1(&b1));
299  CComVariant b2 = b1;
300  ok(V_VT(&b2) == VT_UI1, "Expected .vt to be VT_UI1, was %u\n", V_VT(&b2));
301  ok(V_UI1(&b2) == (BYTE)33, "Expected value to be 33, was: %u\n", V_UI1(&b2));
302  }
303  {
304  CComVariant c1 = (char)33;
305  ok(V_VT(&c1) == VT_I1, "Expected .vt to be VT_I1, was %u\n", V_VT(&c1));
306  ok(V_I1(&c1) == (char)33, "Expected value to be 33, was: %d\n", V_I1(&c1));
307  CComVariant c2 = c1;
308  ok(V_VT(&c2) == VT_I1, "Expected .vt to be VT_I1, was %u\n", V_VT(&c2));
309  ok(V_I1(&c2) == (char)33, "Expected value to be 33, was: %d\n", V_I1(&c2));
310  }
311  {
312  CComVariant s1 = (short)12345;
313  ok(V_VT(&s1) == VT_I2, "Expected .vt to be VT_I2, was %u\n", V_VT(&s1));
314  ok(V_I2(&s1) == (short)12345, "Expected value to be 12345, was: %d\n", V_I1(&s1));
315  CComVariant s2 = s1;
316  ok(V_VT(&s2) == VT_I2, "Expected .vt to be VT_I2, was %u\n", V_VT(&s2));
317  ok(V_I2(&s2) == (short)12345, "Expected value to be 12345, was: %d\n", V_I1(&s2));
318  }
319  {
320  CComVariant us1 = (unsigned short)12345;
321  ok(V_VT(&us1) == VT_UI2, "Expected .vt to be VT_UI2, was %u\n", V_VT(&us1));
322  ok(V_UI2(&us1) == (unsigned short)12345, "Expected value to be 12345, was: %u\n", V_UI2(&us1));
323  CComVariant us2 = us1;
324  ok(V_VT(&us2) == VT_UI2, "Expected .vt to be VT_UI2, was %u\n", V_VT(&us2));
325  ok(V_UI2(&us2) == (unsigned short)12345, "Expected value to be 12345, was: %u\n", V_UI2(&us2));
326  }
327  {
328  CComVariant i1 = (int)4;
329  expect_int(i1, 4, VT_I4);
330  CComVariant i2 = i1;
331  expect_int(i2, 4, VT_I4);
332  }
333  {
334  CComVariant ui1 = (unsigned int)4;
335  expect_uint(ui1, 4, VT_UI4);
336  CComVariant ui2 = ui1;
337  expect_uint(ui2, 4, VT_UI4);
338  }
339  {
340  CComVariant l1 = (long)4;
341  expect_uint(l1, 4, VT_I4);
342  CComVariant l2 = l1;
343  expect_uint(l2, 4, VT_I4);
344  }
345  {
346  CComVariant ul1 = (unsigned long)33;
347  expect_uint(ul1, 33, VT_UI4);
348  CComVariant ul2 = ul1;
349  expect_uint(ul2, 33, VT_UI4);
350  }
351  {
352  CComVariant f1 = 3.4f;
353  ok(V_VT(&f1) == VT_R4, "Expected .vt to be VT_R4, was %u\n", V_VT(&f1));
354  ok(V_R4(&f1) == 3.4f, "Expected value to be 3.4f, was: %f\n", V_R4(&f1));
355  CComVariant f2 = f1;
356  ok(V_VT(&f2) == VT_R4, "Expected .vt to be VT_R4, was %u\n", V_VT(&f2));
357  ok(V_R4(&f2) == 3.4f, "Expected value to be 3.4f, was: %f\n", V_R4(&f2));
358  }
359  {
360  CComVariant d1 = 3.4;
361  expect_double(d1, 3.4, VT_R8);
362  CComVariant d2 = d1;
363  expect_double(d2, 3.4, VT_R8);
364  }
365  {
366  LONGLONG lv = 12030912309123ll;
367  CComVariant l1 = lv;
368  ok(V_VT(&l1) == VT_I8, "Expected .vt to be VT_I8, was %u\n", V_VT(&l1));
369  ok(V_I8(&l1) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_I8(&l1)));
370  CComVariant l2 = l1;
371  ok(V_VT(&l2) == VT_I8, "Expected .vt to be VT_I8, was %u\n", V_VT(&l2));
372  ok(V_I8(&l2) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_I8(&l2)));
373  }
374  {
375  ULONGLONG lv = 12030912309123ull;
376  CComVariant l1 = lv;
377  ok(V_VT(&l1) == VT_UI8, "Expected .vt to be VT_UI8, was %u\n", V_VT(&l1));
378  ok(V_UI8(&l1) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_UI8(&l1)));
379  CComVariant l2 = l1;
380  ok(V_VT(&l2) == VT_UI8, "Expected .vt to be VT_UI8, was %u\n", V_VT(&l2));
381  ok(V_UI8(&l2) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_UI8(&l2)));
382  }
383  {
384  CY cy;
385  cy.int64 = 12030912309123ll;
386  CComVariant c1 = cy;
387  ok(V_VT(&c1) == VT_CY, "Expected .vt to be VT_I8, was %u\n", V_VT(&c1));
388  ok(V_CY(&c1).int64 == cy.int64, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(cy.int64), wine_dbgstr_longlong(V_CY(&c1).int64));
389  CComVariant c2 = c1;
390  ok(V_VT(&c2) == VT_CY, "Expected .vt to be VT_I8, was %u\n", V_VT(&c2));
391  ok(V_CY(&c2).int64 == cy.int64, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(cy.int64), wine_dbgstr_longlong(V_CY(&c2).int64));
392  }
393  // IDispatch
394  // IUnknown
395 }
struct S2 s2
Definition: compat.h:1948
Definition: compat.h:1964
Definition: compat.h:1960
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define V_I2(A)
Definition: oleauto.h:245
long long int64
Definition: platform.h:13
#define V_UI8(A)
Definition: oleauto.h:272
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
Definition: compat.h:1905
#define V_CY(A)
Definition: oleauto.h:229
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:581
#define expect_int
Definition: CComVariant.cpp:56
unsigned char
Definition: typeof.h:29
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
#define V_I8(A)
Definition: oleauto.h:249
int64_t LONGLONG
Definition: typedefs.h:67
GLfloat f
Definition: glext.h:7540
#define V_R4(A)
Definition: oleauto.h:260
#define expect_double
Definition: CComVariant.cpp:58
struct S1 s1
uint64_t ULONGLONG
Definition: typedefs.h:66
#define V_UI1(A)
Definition: oleauto.h:266
#define V_BOOL(A)
Definition: oleauto.h:224
Definition: compat.h:1949
static const WCHAR L[]
Definition: oid.c:1250
#define V_VT(A)
Definition: oleauto.h:211
Definition: compat.h:1951
unsigned char BYTE
Definition: xxhash.c:193
#define V_BSTR(A)
Definition: oleauto.h:226
#define expect_empty
Definition: CComVariant.cpp:60
#define f1(x, y, z)
Definition: sha1.c:30
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define long
Definition: qsort.c:33
#define ok(value,...)
Definition: atltest.h:57
w ll
Definition: byte_order.h:166
BOOL empty
Definition: button.c:170
#define expect_uint
Definition: CComVariant.cpp:57
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
int f2(S1 &, S2 &)
Definition: compat.h:1950
Definition: compat.h:1947
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by START_TEST().

◆ test_construction()

static void test_construction ( )
static

Definition at line 63 of file CComVariant.cpp.

64 {
65  {
66  CComVariant empty;
68  }
69  {
70  CComBSTR bstr(L"TESTW");
71  CComVariant olestr((LPCOLESTR)bstr), comstr(bstr);
72  ok(V_VT(&olestr) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&olestr));
73  ok(!wcscmp(V_BSTR(&olestr), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&olestr)));
74  ok(V_VT(&comstr) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&comstr));
75  ok(!wcscmp(V_BSTR(&comstr), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&comstr)));
76  }
77  {
78  CComVariant cstr((LPCSTR)"TESTA");
79  ok(V_VT(&cstr) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&cstr));
80  ok(!wcscmp(V_BSTR(&cstr), L"TESTA"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&cstr)));
81  }
82  {
83  CComVariant trueVal(true), falseVal(false);
84  ok(V_VT(&trueVal) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&trueVal));
85  ok(V_BOOL(&trueVal) == VARIANT_TRUE, "Expected value to be VARIANT_TRUE, was: %u\n", V_BOOL(&trueVal));
86  ok(V_VT(&falseVal) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&falseVal));
87  ok(V_BOOL(&falseVal) == VARIANT_FALSE, "Expected value to be VARIANT_TRUE, was: %u\n", V_BOOL(&falseVal));
88  }
89  {
90  CComVariant b1((BYTE)33);
91  ok(V_VT(&b1) == VT_UI1, "Expected .vt to be VT_UI1, was %u\n", V_VT(&b1));
92  ok(V_UI1(&b1) == (BYTE)33, "Expected value to be 33, was: %u\n", V_UI1(&b1));
93  }
94  {
95  CComVariant c1((char)33);
96  ok(V_VT(&c1) == VT_I1, "Expected .vt to be VT_I1, was %u\n", V_VT(&c1));
97  ok(V_I1(&c1) == (char)33, "Expected value to be 33, was: %d\n", V_I1(&c1));
98  }
99  {
100  CComVariant s1((short)12345);
101  ok(V_VT(&s1) == VT_I2, "Expected .vt to be VT_I2, was %u\n", V_VT(&s1));
102  ok(V_I2(&s1) == (short)12345, "Expected value to be 12345, was: %d\n", V_I1(&s1));
103  }
104  {
105  CComVariant us1((unsigned short)12345);
106  ok(V_VT(&us1) == VT_UI2, "Expected .vt to be VT_UI2, was %u\n", V_VT(&us1));
107  ok(V_UI2(&us1) == (unsigned short)12345, "Expected value to be 12345, was: %u\n", V_UI2(&us1));
108  }
109  {
110  CComVariant i1((int)4, VT_I4), i2((int)3, VT_INT), i3((int)2, VT_I2), i4((int)1);
111  expect_int(i1, 4, VT_I4);
112  expect_int(i2, 3, VT_INT);
114  expect_int(i4, 1, VT_I4);
115  }
116  {
117  CComVariant ui1((unsigned int)4, VT_UI4), ui2((unsigned int)3, VT_UINT), ui3((unsigned int)2, VT_UI2), ui4((unsigned int)1);
118  expect_uint(ui1, 4, VT_UI4);
119  expect_uint(ui2, 3, VT_UINT);
121  expect_uint(ui4, 1, VT_UI4);
122  }
123  {
124  CComVariant l1((long)4, VT_I4), l2((long)3, VT_INT), l3((long)2, VT_ERROR), l4((long)1);
125  expect_int(l1, 4, VT_I4);
127  expect_error(l3, 2);
128  expect_int(l4, 1, VT_I4);
129  }
130  {
131  CComVariant ul1((unsigned long)33);
132  expect_uint(ul1, 33, VT_UI4);
133  }
134  {
135  CComVariant f1(3.4f);
136  ok(V_VT(&f1) == VT_R4, "Expected .vt to be VT_R4, was %u\n", V_VT(&f1));
137  ok(V_R4(&f1) == 3.4f, "Expected value to be 3.4f, was: %f\n", V_R4(&f1));
138  }
139  {
140  CComVariant d1(3.4, VT_R8), d2(3.4, VT_DATE), d3(8.8, VT_I1), d4(1.9);
141  expect_double(d1, 3.4, VT_R8);
142  expect_double(d2, 3.4, VT_DATE);
144  expect_double(d4, 1.9, VT_R8);
145  }
146  {
147  LONGLONG lv = 12030912309123ll;
148  CComVariant l1(lv);
149  ok(V_VT(&l1) == VT_I8, "Expected .vt to be VT_I8, was %u\n", V_VT(&l1));
150  ok(V_I8(&l1) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_I8(&l1)));
151  }
152  {
153  ULONGLONG lv = 12030912309123ull;
154  CComVariant l1(lv);
155  ok(V_VT(&l1) == VT_UI8, "Expected .vt to be VT_UI8, was %u\n", V_VT(&l1));
156  ok(V_UI8(&l1) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_UI8(&l1)));
157  }
158  {
159  CY cy;
160  cy.int64 = 12030912309123ll;
161  CComVariant c1(cy);
162  ok(V_VT(&c1) == VT_CY, "Expected .vt to be VT_CY, was %u\n", V_VT(&c1));
163  ok(V_CY(&c1).int64 == cy.int64, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(cy.int64), wine_dbgstr_longlong(V_CY(&c1).int64));
164  }
165  // IDispatch
166  // IUnknown
167 }
Definition: compat.h:1948
Definition: compat.h:1964
Definition: compat.h:1960
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define V_I2(A)
Definition: oleauto.h:245
#define expect_error
Definition: CComVariant.cpp:59
long long int64
Definition: platform.h:13
#define V_UI8(A)
Definition: oleauto.h:272
Definition: compat.h:1905
#define V_CY(A)
Definition: oleauto.h:229
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:581
#define E_INVALIDARG
Definition: ddrawi.h:101
#define expect_int
Definition: CComVariant.cpp:56
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
const char * LPCSTR
Definition: xmlstorage.h:183
#define V_I8(A)
Definition: oleauto.h:249
int64_t LONGLONG
Definition: typedefs.h:67
GLfloat f
Definition: glext.h:7540
#define V_R4(A)
Definition: oleauto.h:260
#define expect_double
Definition: CComVariant.cpp:58
struct S1 s1
uint64_t ULONGLONG
Definition: typedefs.h:66
#define V_UI1(A)
Definition: oleauto.h:266
#define V_BOOL(A)
Definition: oleauto.h:224
Definition: compat.h:1949
static const WCHAR L[]
Definition: oid.c:1250
#define V_VT(A)
Definition: oleauto.h:211
Definition: compat.h:1951
unsigned char BYTE
Definition: xxhash.c:193
#define V_BSTR(A)
Definition: oleauto.h:226
#define expect_empty
Definition: CComVariant.cpp:60
#define f1(x, y, z)
Definition: sha1.c:30
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define ok(value,...)
Definition: atltest.h:57
w ll
Definition: byte_order.h:166
BOOL empty
Definition: button.c:170
#define expect_uint
Definition: CComVariant.cpp:57
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
Definition: compat.h:1950
Definition: compat.h:1947

Referenced by START_TEST().

◆ test_copyconstructor()

static void test_copyconstructor ( )
static

Definition at line 170 of file CComVariant.cpp.

171 {
172  {
173  CComVariant empty;
174  CComVariant empty2(empty);
175  expect_empty(empty2);
176  }
177  {
178  CComBSTR bstr(L"TESTW");
179  CComVariant olestr((LPCOLESTR)bstr);
180  CComVariant olestr2(olestr);
181  ok(V_VT(&olestr2) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&olestr2));
182  ok(!wcscmp(V_BSTR(&olestr2), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&olestr2)));
183  }
184  {
185  CComVariant trueVal(true);
186  CComVariant trueVal2(trueVal);
187  ok(V_VT(&trueVal2) == VT_BOOL, "Expected .vt to be BOOL, was %u\n", V_VT(&trueVal2));
188  ok(V_BOOL(&trueVal2) == VARIANT_TRUE, "Expected value to be VARIANT_TRUE, was: %u\n", V_BOOL(&trueVal2));
189  }
190  {
191  CComVariant b1((BYTE)33);
192  CComVariant b2(b1);
193  ok(V_VT(&b2) == VT_UI1, "Expected .vt to be VT_UI1, was %u\n", V_VT(&b2));
194  ok(V_UI1(&b2) == (BYTE)33, "Expected value to be 33, was: %u\n", V_UI1(&b2));
195  }
196  {
197  CComVariant c1((char)33);
198  CComVariant c2(c1);
199  ok(V_VT(&c2) == VT_I1, "Expected .vt to be VT_I1, was %u\n", V_VT(&c2));
200  ok(V_I1(&c2) == (char)33, "Expected value to be 33, was: %d\n", V_I1(&c2));
201  }
202  {
203  CComVariant s1((short)12345);
204  CComVariant s2(s1);
205  ok(V_VT(&s2) == VT_I2, "Expected .vt to be VT_I2, was %u\n", V_VT(&s2));
206  ok(V_I2(&s2) == (short)12345, "Expected value to be 12345, was: %d\n", V_I1(&s2));
207  }
208  {
209  CComVariant us1((unsigned short)12345);
210  CComVariant us2(us1);
211  ok(V_VT(&us2) == VT_UI2, "Expected .vt to be VT_UI2, was %u\n", V_VT(&us2));
212  ok(V_UI2(&us2) == (unsigned short)12345, "Expected value to be 12345, was: %u\n", V_UI2(&us2));
213  }
214  {
215  CComVariant i1((int)4, VT_I4);
216  CComVariant i2(i1);
217  expect_int(i2, 4, VT_I4);
218  }
219  {
220  CComVariant ui1((unsigned int)4, VT_UI4);
221  CComVariant ui2(ui1);
222  expect_uint(ui2, 4, VT_UI4);
223  }
224  {
225  CComVariant l1((long)4, VT_I4);
226  CComVariant l2(l1);
227  expect_uint(l2, 4, VT_I4);
228  }
229  {
230  CComVariant ul1((unsigned long)33);
231  CComVariant ul2(ul1);
232  expect_uint(ul2, 33, VT_UI4);
233  }
234  {
235  CComVariant f1(3.4f);
236  CComVariant f2(f1);
237  ok(V_VT(&f2) == VT_R4, "Expected .vt to be VT_R4, was %u\n", V_VT(&f2));
238  ok(V_R4(&f2) == 3.4f, "Expected value to be 3.4f, was: %f\n", V_R4(&f2));
239  }
240  {
241  CComVariant d1(3.4, VT_R8);
242  CComVariant d2(d1);
243  expect_double(d2, 3.4, VT_R8);
244  }
245  {
246  LONGLONG lv = 12030912309123ll;
247  CComVariant l1(lv);
248  CComVariant l2(l1);
249  ok(V_VT(&l2) == VT_I8, "Expected .vt to be VT_I8, was %u\n", V_VT(&l2));
250  ok(V_I8(&l2) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_I8(&l2)));
251  }
252  {
253  ULONGLONG lv = 12030912309123ull;
254  CComVariant l1(lv);
255  CComVariant l2(l1);
256  ok(V_VT(&l2) == VT_UI8, "Expected .vt to be VT_UI8, was %u\n", V_VT(&l2));
257  ok(V_UI8(&l2) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_UI8(&l2)));
258  }
259  {
260  CY cy;
261  cy.int64 = 12030912309123ll;
262  CComVariant c1(cy);
263  CComVariant c2(c1);
264  ok(V_VT(&c2) == VT_CY, "Expected .vt to be VT_I8, was %u\n", V_VT(&c2));
265  ok(V_CY(&c2).int64 == cy.int64, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(cy.int64), wine_dbgstr_longlong(V_CY(&c2).int64));
266  }
267  // IDispatch
268  // IUnknown
269 }
struct S2 s2
Definition: compat.h:1948
Definition: compat.h:1964
Definition: compat.h:1960
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
#define V_I2(A)
Definition: oleauto.h:245
long long int64
Definition: platform.h:13
#define V_UI8(A)
Definition: oleauto.h:272
Definition: compat.h:1905
#define V_CY(A)
Definition: oleauto.h:229
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:581
#define expect_int
Definition: CComVariant.cpp:56
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
#define V_I8(A)
Definition: oleauto.h:249
int64_t LONGLONG
Definition: typedefs.h:67
GLfloat f
Definition: glext.h:7540
#define V_R4(A)
Definition: oleauto.h:260
#define expect_double
Definition: CComVariant.cpp:58
struct S1 s1
uint64_t ULONGLONG
Definition: typedefs.h:66
#define V_UI1(A)
Definition: oleauto.h:266
#define V_BOOL(A)
Definition: oleauto.h:224
Definition: compat.h:1949
static const WCHAR L[]
Definition: oid.c:1250
#define V_VT(A)
Definition: oleauto.h:211
Definition: compat.h:1951
unsigned char BYTE
Definition: xxhash.c:193
#define V_BSTR(A)
Definition: oleauto.h:226
#define expect_empty
Definition: CComVariant.cpp:60
#define f1(x, y, z)
Definition: sha1.c:30
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define ok(value,...)
Definition: atltest.h:57
w ll
Definition: byte_order.h:166
BOOL empty
Definition: button.c:170
#define expect_uint
Definition: CComVariant.cpp:57
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
int f2(S1 &, S2 &)
Definition: compat.h:1950
Definition: compat.h:1947

Referenced by START_TEST().

◆ test_misc()

static void test_misc ( )
static

Definition at line 397 of file CComVariant.cpp.

398 {
399  HRESULT hr;
400  {
401  CComVariant empty;
402  hr = empty.Clear();
403  ok(SUCCEEDED(hr), "Expected .Clear() to succeed, but it failed: 0x%lx\n", hr);
405  }
406 
407  {
408  CComBSTR bstr(L"TESTW");
409  CComVariant olestr((LPCOLESTR)bstr), empty;
410 
411  hr = empty.Copy(&olestr); // VARIANT*
412  ok(SUCCEEDED(hr), "Expected .Copy() to succeed, but it failed: 0x%lx\n", hr);
413  ok(V_VT(&empty) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&empty));
414  ok(!wcscmp(V_BSTR(&empty), L"TESTW"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&empty)));
415 
416  /* Clear does not null out the rest, it just sets .vt! */
417  hr = olestr.Clear();
418  ok(SUCCEEDED(hr), "Expected .Clear() to succeed, but it failed: 0x%lx\n", hr);
419  ok(V_VT(&olestr) == VT_EMPTY, "Expected .vt to be VT_EMPTY, was %u\n", V_VT(&olestr));
420  }
421 
422  {
423  CComVariant d1(3.4, VT_R8), empty;
424  hr = empty.Copy(&d1);
425  ok(SUCCEEDED(hr), "Expected .Copy() to succeed, but it failed: 0x%lx\n", hr);
426  expect_double(empty, 3.4, VT_R8);
427  }
428 
429  {
430  LONGLONG lv = 12030912309123ll;
431  CComVariant l1(lv);
432  CComVariant empty;
433  hr = empty.Copy(&l1);
434  ok(SUCCEEDED(hr), "Expected .Copy() to succeed, but it failed: 0x%lx\n", hr);
435  ok(V_VT(&empty) == VT_I8, "Expected .vt to be VT_I8, was %u\n", V_VT(&empty));
436  ok(V_I8(&empty) == lv, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(lv), wine_dbgstr_longlong(V_I8(&empty)));
437  }
438 
439  {
440  CY cy;
441  cy.int64 = 12030912309123ll;
442  CComVariant c1(cy);
443  CComVariant empty;
444  hr = empty.Copy(&c1);
445  ok(SUCCEEDED(hr), "Expected .Copy() to succeed, but it failed: 0x%lx\n", hr);
446  ok(V_VT(&empty) == VT_CY, "Expected .vt to be VT_I8, was %u\n", V_VT(&empty));
447  ok(V_CY(&empty).int64 == cy.int64, "Expected value to be %s, was: %s\n", wine_dbgstr_longlong(cy.int64), wine_dbgstr_longlong(V_CY(&empty).int64));
448  }
449  {
450  CComVariant var = (int)333;
451  CComVariant var2;
452  // var2 = var changed to bstr
453  HRESULT hr = var2.ChangeType(VT_BSTR, &var);
454  ok(SUCCEEDED(hr), "Expected .ChangeType() to succeed, but it failed: 0x%lx\n", hr);
455  expect_int(var, 333, VT_I4);
456  ok(V_VT(&var2) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&var2));
457  ok(!wcscmp(V_BSTR(&var2), L"333"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&var2)));
458 
459  // change in place
460  hr = var.ChangeType(VT_BSTR);
461  ok(SUCCEEDED(hr), "Expected .ChangeType() to succeed, but it failed: 0x%lx\n", hr);
462  ok(V_VT(&var) == VT_BSTR, "Expected .vt to be VT_LPWSTR, was %u\n", V_VT(&var));
463  ok(!wcscmp(V_BSTR(&var), L"333"), "Expected value to be L\"TESTW\", was: %s\n", wine_dbgstr_w(V_BSTR(&var)));
464  }
465 }
const char * var
Definition: shader.c:5666
Definition: compat.h:1948
Definition: compat.h:1964
HRESULT hr
Definition: shlfolder.c:183
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
long long int64
Definition: platform.h:13
Definition: compat.h:1905
#define V_CY(A)
Definition: oleauto.h:229
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:581
#define expect_int
Definition: CComVariant.cpp:56
#define V_I8(A)
Definition: oleauto.h:249
int64_t LONGLONG
Definition: typedefs.h:67
LONG HRESULT
Definition: typedefs.h:78
#define expect_double
Definition: CComVariant.cpp:58
static const WCHAR L[]
Definition: oid.c:1250
#define V_VT(A)
Definition: oleauto.h:211
Definition: compat.h:1951
#define V_BSTR(A)
Definition: oleauto.h:226
#define expect_empty
Definition: CComVariant.cpp:60
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
#define ok(value,...)
Definition: atltest.h:57
w ll
Definition: byte_order.h:166
BOOL empty
Definition: button.c:170
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
Definition: compat.h:1950
#define SUCCEEDED(hr)
Definition: intsafe.h:57
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31

Referenced by START_TEST().