1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/win/scoped_variant.h" 6 #include "testing/gtest/include/gtest/gtest.h" 7 8 namespace base { 9 namespace win { 10 11 namespace { 12 13 static const wchar_t kTestString1[] = L"Used to create BSTRs"; 14 static const wchar_t kTestString2[] = L"Also used to create BSTRs"; 15 16 void GiveMeAVariant(VARIANT* ret) { 17 EXPECT_TRUE(ret != NULL); 18 ret->vt = VT_BSTR; 19 V_BSTR(ret) = ::SysAllocString(kTestString1); 20 } 21 22 // A dummy IDispatch implementation (if you can call it that). 23 // The class does nothing intelligent really. Only increments a counter 24 // when AddRef is called and decrements it when Release is called. 25 class FakeComObject : public IDispatch { 26 public: 27 FakeComObject() : ref_(0) { 28 } 29 30 STDMETHOD_(DWORD, AddRef)() { 31 ref_++; 32 return ref_; 33 } 34 35 STDMETHOD_(DWORD, Release)() { 36 ref_--; 37 return ref_; 38 } 39 40 STDMETHOD(QueryInterface)(REFIID, void**) { 41 return E_NOTIMPL; 42 } 43 44 STDMETHOD(GetTypeInfoCount)(UINT*) { 45 return E_NOTIMPL; 46 } 47 48 STDMETHOD(GetTypeInfo)(UINT, LCID, ITypeInfo**) { 49 return E_NOTIMPL; 50 } 51 52 STDMETHOD(GetIDsOfNames)(REFIID, LPOLESTR*, UINT, LCID, DISPID*) { 53 return E_NOTIMPL; 54 } 55 56 STDMETHOD(Invoke)(DISPID, REFIID, LCID, WORD, DISPPARAMS*, VARIANT*, 57 EXCEPINFO*, UINT*) { 58 return E_NOTIMPL; 59 } 60 61 // A way to check the internal reference count of the class. 62 int ref_count() const { 63 return ref_; 64 } 65 66 protected: 67 int ref_; 68 }; 69 70 } // namespace 71 72 TEST(ScopedVariantTest, ScopedVariant) { 73 ScopedVariant var; 74 EXPECT_TRUE(var.type() == VT_EMPTY); 75 // V_BSTR(&var) = NULL; <- NOTE: Assignment like that is not supported 76 77 ScopedVariant var_bstr(L"VT_BSTR"); 78 EXPECT_EQ(VT_BSTR, V_VT(&var_bstr)); 79 EXPECT_TRUE(V_BSTR(&var_bstr) != NULL); // can't use EXPECT_NE for BSTR 80 var_bstr.Reset(); 81 EXPECT_NE(VT_BSTR, V_VT(&var_bstr)); 82 var_bstr.Set(kTestString2); 83 EXPECT_EQ(VT_BSTR, V_VT(&var_bstr)); 84 85 VARIANT tmp = var_bstr.Release(); 86 EXPECT_EQ(VT_EMPTY, V_VT(&var_bstr)); 87 EXPECT_EQ(VT_BSTR, V_VT(&tmp)); 88 EXPECT_EQ(0, lstrcmp(V_BSTR(&tmp), kTestString2)); 89 90 var.Reset(tmp); 91 EXPECT_EQ(VT_BSTR, V_VT(&var)); 92 EXPECT_EQ(0, lstrcmpW(V_BSTR(&var), kTestString2)); 93 94 var_bstr.Swap(var); 95 EXPECT_EQ(VT_EMPTY, V_VT(&var)); 96 EXPECT_EQ(VT_BSTR, V_VT(&var_bstr)); 97 EXPECT_EQ(0, lstrcmpW(V_BSTR(&var_bstr), kTestString2)); 98 var_bstr.Reset(); 99 100 // Test the Compare and Copy routines. 101 GiveMeAVariant(var_bstr.Receive()); 102 ScopedVariant var_bstr2(V_BSTR(&var_bstr)); 103 EXPECT_EQ(0, var_bstr.Compare(var_bstr2)); 104 var_bstr2.Reset(); 105 EXPECT_NE(0, var_bstr.Compare(var_bstr2)); 106 var_bstr2.Reset(var_bstr.Copy()); 107 EXPECT_EQ(0, var_bstr.Compare(var_bstr2)); 108 var_bstr2.Reset(); 109 var_bstr2.Set(V_BSTR(&var_bstr)); 110 EXPECT_EQ(0, var_bstr.Compare(var_bstr2)); 111 var_bstr2.Reset(); 112 var_bstr.Reset(); 113 114 // Test for the SetDate setter. 115 SYSTEMTIME sys_time; 116 ::GetSystemTime(&sys_time); 117 DATE date; 118 ::SystemTimeToVariantTime(&sys_time, &date); 119 var.Reset(); 120 var.SetDate(date); 121 EXPECT_EQ(VT_DATE, var.type()); 122 EXPECT_EQ(date, V_DATE(&var)); 123 124 // Simple setter tests. These do not require resetting the variant 125 // after each test since the variant type is not "leakable" (i.e. doesn't 126 // need to be freed explicitly). 127 128 // We need static cast here since char defaults to int (!?). 129 var.Set(static_cast<int8>('v')); 130 EXPECT_EQ(VT_I1, var.type()); 131 EXPECT_EQ('v', V_I1(&var)); 132 133 var.Set(static_cast<short>(123)); 134 EXPECT_EQ(VT_I2, var.type()); 135 EXPECT_EQ(123, V_I2(&var)); 136 137 var.Set(static_cast<int32>(123)); 138 EXPECT_EQ(VT_I4, var.type()); 139 EXPECT_EQ(123, V_I4(&var)); 140 141 var.Set(static_cast<int64>(123)); 142 EXPECT_EQ(VT_I8, var.type()); 143 EXPECT_EQ(123, V_I8(&var)); 144 145 var.Set(static_cast<uint8>(123)); 146 EXPECT_EQ(VT_UI1, var.type()); 147 EXPECT_EQ(123, V_UI1(&var)); 148 149 var.Set(static_cast<unsigned short>(123)); 150 EXPECT_EQ(VT_UI2, var.type()); 151 EXPECT_EQ(123, V_UI2(&var)); 152 153 var.Set(static_cast<uint32>(123)); 154 EXPECT_EQ(VT_UI4, var.type()); 155 EXPECT_EQ(123, V_UI4(&var)); 156 157 var.Set(static_cast<uint64>(123)); 158 EXPECT_EQ(VT_UI8, var.type()); 159 EXPECT_EQ(123, V_UI8(&var)); 160 161 var.Set(123.123f); 162 EXPECT_EQ(VT_R4, var.type()); 163 EXPECT_EQ(123.123f, V_R4(&var)); 164 165 var.Set(static_cast<double>(123.123)); 166 EXPECT_EQ(VT_R8, var.type()); 167 EXPECT_EQ(123.123, V_R8(&var)); 168 169 var.Set(true); 170 EXPECT_EQ(VT_BOOL, var.type()); 171 EXPECT_EQ(VARIANT_TRUE, V_BOOL(&var)); 172 var.Set(false); 173 EXPECT_EQ(VT_BOOL, var.type()); 174 EXPECT_EQ(VARIANT_FALSE, V_BOOL(&var)); 175 176 // Com interface tests 177 178 var.Set(static_cast<IDispatch*>(NULL)); 179 EXPECT_EQ(VT_DISPATCH, var.type()); 180 EXPECT_EQ(NULL, V_DISPATCH(&var)); 181 var.Reset(); 182 183 var.Set(static_cast<IUnknown*>(NULL)); 184 EXPECT_EQ(VT_UNKNOWN, var.type()); 185 EXPECT_EQ(NULL, V_UNKNOWN(&var)); 186 var.Reset(); 187 188 FakeComObject faker; 189 EXPECT_EQ(0, faker.ref_count()); 190 var.Set(static_cast<IDispatch*>(&faker)); 191 EXPECT_EQ(VT_DISPATCH, var.type()); 192 EXPECT_EQ(&faker, V_DISPATCH(&var)); 193 EXPECT_EQ(1, faker.ref_count()); 194 var.Reset(); 195 EXPECT_EQ(0, faker.ref_count()); 196 197 var.Set(static_cast<IUnknown*>(&faker)); 198 EXPECT_EQ(VT_UNKNOWN, var.type()); 199 EXPECT_EQ(&faker, V_UNKNOWN(&var)); 200 EXPECT_EQ(1, faker.ref_count()); 201 var.Reset(); 202 EXPECT_EQ(0, faker.ref_count()); 203 204 { 205 ScopedVariant disp_var(&faker); 206 EXPECT_EQ(VT_DISPATCH, disp_var.type()); 207 EXPECT_EQ(&faker, V_DISPATCH(&disp_var)); 208 EXPECT_EQ(1, faker.ref_count()); 209 } 210 EXPECT_EQ(0, faker.ref_count()); 211 212 { 213 ScopedVariant ref1(&faker); 214 EXPECT_EQ(1, faker.ref_count()); 215 ScopedVariant ref2(static_cast<const VARIANT&>(ref1)); 216 EXPECT_EQ(2, faker.ref_count()); 217 ScopedVariant ref3; 218 ref3 = static_cast<const VARIANT&>(ref2); 219 EXPECT_EQ(3, faker.ref_count()); 220 } 221 EXPECT_EQ(0, faker.ref_count()); 222 223 { 224 ScopedVariant unk_var(static_cast<IUnknown*>(&faker)); 225 EXPECT_EQ(VT_UNKNOWN, unk_var.type()); 226 EXPECT_EQ(&faker, V_UNKNOWN(&unk_var)); 227 EXPECT_EQ(1, faker.ref_count()); 228 } 229 EXPECT_EQ(0, faker.ref_count()); 230 231 VARIANT raw; 232 raw.vt = VT_UNKNOWN; 233 raw.punkVal = &faker; 234 EXPECT_EQ(0, faker.ref_count()); 235 var.Set(raw); 236 EXPECT_EQ(1, faker.ref_count()); 237 var.Reset(); 238 EXPECT_EQ(0, faker.ref_count()); 239 240 { 241 ScopedVariant number(123); 242 EXPECT_EQ(VT_I4, number.type()); 243 EXPECT_EQ(123, V_I4(&number)); 244 } 245 246 // SAFEARRAY tests 247 var.Set(static_cast<SAFEARRAY*>(NULL)); 248 EXPECT_EQ(VT_EMPTY, var.type()); 249 250 SAFEARRAY* sa = ::SafeArrayCreateVector(VT_UI1, 0, 100); 251 ASSERT_TRUE(sa != NULL); 252 253 var.Set(sa); 254 EXPECT_TRUE(ScopedVariant::IsLeakableVarType(var.type())); 255 EXPECT_EQ(VT_ARRAY | VT_UI1, var.type()); 256 EXPECT_EQ(sa, V_ARRAY(&var)); 257 // The array is destroyed in the destructor of var. 258 } 259 260 } // namespace win 261 } // namespace base 262
