• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2020 The Chromium Authors
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/variant_vector.h"
6 
7 #include <stddef.h>
8 #include <windows.foundation.h>
9 #include <wrl/client.h>
10 
11 #include "base/test/gtest_util.h"
12 #include "base/win/dispatch_stub.h"
13 #include "base/win/scoped_safearray.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15 #include "third_party/abseil-cpp/absl/types/optional.h"
16 
17 using base::win::test::DispatchStub;
18 
19 namespace base {
20 namespace win {
21 
TEST(VariantVectorTest,InitiallyEmpty)22 TEST(VariantVectorTest, InitiallyEmpty) {
23   VariantVector vector;
24   EXPECT_EQ(vector.Type(), VT_EMPTY);
25   EXPECT_EQ(vector.Size(), 0U);
26   EXPECT_TRUE(vector.Empty());
27 }
28 
TEST(VariantVectorTest,MoveConstructor)29 TEST(VariantVectorTest, MoveConstructor) {
30   VariantVector vector1;
31   Microsoft::WRL::ComPtr<IDispatch> dispatch =
32       Microsoft::WRL::Make<DispatchStub>();
33   vector1.Insert<VT_DISPATCH>(dispatch.Get());
34   EXPECT_EQ(vector1.Type(), VT_DISPATCH);
35   EXPECT_EQ(vector1.Size(), 1U);
36 
37   VariantVector vector2(std::move(vector1));
38   EXPECT_EQ(vector1.Type(), VT_EMPTY);
39   EXPECT_EQ(vector1.Size(), 0U);
40   EXPECT_EQ(vector2.Type(), VT_DISPATCH);
41   EXPECT_EQ(vector2.Size(), 1U);
42   // |dispatch| should have been transferred to |vector2|.
43   EXPECT_EQ(dispatch.Reset(), 1U);
44 }
45 
TEST(VariantVectorTest,MoveAssignOperator)46 TEST(VariantVectorTest, MoveAssignOperator) {
47   VariantVector vector1, vector2;
48   Microsoft::WRL::ComPtr<IDispatch> dispatch1 =
49       Microsoft::WRL::Make<DispatchStub>();
50   Microsoft::WRL::ComPtr<IDispatch> dispatch2 =
51       Microsoft::WRL::Make<DispatchStub>();
52   vector1.Insert<VT_DISPATCH>(dispatch1.Get());
53   vector2.Insert<VT_UNKNOWN>(dispatch2.Get());
54   EXPECT_EQ(vector1.Type(), VT_DISPATCH);
55   EXPECT_EQ(vector1.Size(), 1U);
56   EXPECT_EQ(vector2.Type(), VT_UNKNOWN);
57   EXPECT_EQ(vector2.Size(), 1U);
58   vector1 = std::move(vector2);
59   EXPECT_EQ(vector1.Type(), VT_UNKNOWN);
60   EXPECT_EQ(vector1.Size(), 1U);
61   EXPECT_EQ(vector2.Type(), VT_EMPTY);
62   EXPECT_EQ(vector2.Size(), 0U);
63   // |dispatch1| should have been released during the move.
64   EXPECT_EQ(dispatch1.Reset(), 0U);
65   // |dispatch2| should have been transferred to |vector1|.
66   EXPECT_EQ(dispatch2.Reset(), 1U);
67 
68   // Indirectly move |vector1| into itself.
69   VariantVector& reference_to_vector1 = vector1;
70   EXPECT_DCHECK_DEATH(vector1 = std::move(reference_to_vector1));
71 }
72 
TEST(VariantVectorTest,Insert)73 TEST(VariantVectorTest, Insert) {
74   VariantVector vector;
75   vector.Insert<VT_I4>(123);
76   EXPECT_EQ(vector.Type(), VT_I4);
77   // The first insert sets the type to VT_I4, and attempting to insert
78   // unrelated types will silently fail in release builds but DCHECKs
79   // in debug builds.
80   EXPECT_DCHECK_DEATH(vector.Insert<VT_UI4>(1U));
81   EXPECT_DCHECK_DEATH(vector.Insert<VT_R8>(100.0));
82   EXPECT_EQ(vector.Type(), VT_I4);
83   EXPECT_EQ(vector.Size(), 1U);
84   EXPECT_FALSE(vector.Empty());
85 }
86 
TEST(VariantVectorTest,InsertCanUpcastDispatchToUnknown)87 TEST(VariantVectorTest, InsertCanUpcastDispatchToUnknown) {
88   Microsoft::WRL::ComPtr<IDispatch> dispatch =
89       Microsoft::WRL::Make<DispatchStub>();
90   Microsoft::WRL::ComPtr<IDispatch> unknown;
91   dispatch.CopyTo(&unknown);
92 
93   VariantVector vector;
94   vector.Insert<VT_UNKNOWN>(unknown.Get());
95   vector.Insert<VT_UNKNOWN>(dispatch.Get());
96   vector.Insert<VT_DISPATCH>(dispatch.Get());
97   EXPECT_EQ(vector.Type(), VT_UNKNOWN);
98   EXPECT_EQ(vector.Size(), 3U);
99 }
100 
TEST(VariantVectorTest,InsertCannotDowncastUnknownToDispatch)101 TEST(VariantVectorTest, InsertCannotDowncastUnknownToDispatch) {
102   Microsoft::WRL::ComPtr<IDispatch> dispatch =
103       Microsoft::WRL::Make<DispatchStub>();
104   Microsoft::WRL::ComPtr<IDispatch> unknown;
105   dispatch.CopyTo(&unknown);
106 
107   VariantVector vector;
108   vector.Insert<VT_DISPATCH>(dispatch.Get());
109   // The first insert sets the type to VT_DISPATCH, and attempting to
110   // explicitly insert VT_UNKNOWN will silently fail in release builds
111   // but DCHECKs in debug builds.
112   EXPECT_DCHECK_DEATH(vector.Insert<VT_UNKNOWN>(unknown.Get()));
113   EXPECT_DCHECK_DEATH(vector.Insert<VT_UNKNOWN>(dispatch.Get()));
114   EXPECT_EQ(vector.Type(), VT_DISPATCH);
115   EXPECT_EQ(vector.Size(), 1U);
116 }
117 
TEST(VariantVectorTest,Reset)118 TEST(VariantVectorTest, Reset) {
119   VariantVector vector;
120   EXPECT_EQ(vector.Type(), VT_EMPTY);
121   EXPECT_EQ(vector.Size(), 0U);
122   vector.Insert<VT_I4>(123);
123   vector.Insert<VT_I4>(456);
124   EXPECT_EQ(vector.Type(), VT_I4);
125   EXPECT_EQ(vector.Size(), 2U);
126   vector.Reset();
127   EXPECT_EQ(vector.Type(), VT_EMPTY);
128   EXPECT_EQ(vector.Size(), 0U);
129 }
130 
TEST(VariantVectorTest,ResetWithManagedContents)131 TEST(VariantVectorTest, ResetWithManagedContents) {
132   VariantVector vector;
133   // Test that managed contents are released when cleared.
134   Microsoft::WRL::ComPtr<IUnknown> unknown1 =
135       Microsoft::WRL::Make<DispatchStub>();
136   Microsoft::WRL::ComPtr<IUnknown> unknown2;
137   unknown1.CopyTo(&unknown2);
138   vector.Insert<VT_UNKNOWN>(unknown1.Get());
139   EXPECT_EQ(vector.Type(), VT_UNKNOWN);
140   EXPECT_EQ(vector.Size(), 1U);
141   // There are now 3 references to the value owned by |unknown1|.
142   // Remove ownership from |unknown2| should reduce the count to 2.
143   EXPECT_EQ(unknown2.Reset(), 2U);
144   // Resetting the VariantVector will reduce the count to 1.
145   vector.Reset();
146   EXPECT_EQ(vector.Type(), VT_EMPTY);
147   EXPECT_EQ(vector.Size(), 0U);
148   // Then resetting |unknown1| should reduce to 0.
149   EXPECT_EQ(unknown1.Reset(), 0U);
150 }
151 
TEST(VariantVectorTest,ScopeWithManagedContents)152 TEST(VariantVectorTest, ScopeWithManagedContents) {
153   Microsoft::WRL::ComPtr<IUnknown> unknown1 =
154       Microsoft::WRL::Make<DispatchStub>();
155   {
156     VariantVector vector;
157     vector.Insert<VT_UNKNOWN>(unknown1.Get());
158     EXPECT_EQ(vector.Type(), VT_UNKNOWN);
159     EXPECT_EQ(vector.Size(), 1U);
160 
161     Microsoft::WRL::ComPtr<IUnknown> unknown2;
162     unknown1.CopyTo(&unknown2);
163     // There are now 3 references to the value owned by |unknown1|.
164     // Remove ownership from |unknown2| should reduce the count to 2.
165     EXPECT_EQ(unknown2.Reset(), 2U);
166   }
167   // The VariantVector going out of scope will reduce the count to 1.
168   // Then resetting |unknown1| should reduce to 0.
169   EXPECT_EQ(unknown1.Reset(), 0U);
170 }
171 
TEST(VariantVectorTest,ReleaseAsScalarVariantEmpty)172 TEST(VariantVectorTest, ReleaseAsScalarVariantEmpty) {
173   VariantVector vector;
174   ScopedVariant variant(vector.ReleaseAsScalarVariant());
175   EXPECT_EQ(variant.type(), VT_EMPTY);
176 }
177 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleBool)178 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleBool) {
179   VariantVector vector;
180   ScopedVariant expected_variant;
181 
182   expected_variant.Set(true);
183   vector.Insert<VT_BOOL>(true);
184   EXPECT_EQ(vector.Type(), expected_variant.type());
185   EXPECT_EQ(vector.Size(), 1U);
186 
187   ScopedVariant variant(vector.ReleaseAsScalarVariant());
188   EXPECT_EQ(vector.Type(), VT_EMPTY);
189   EXPECT_EQ(vector.Size(), 0U);
190   EXPECT_EQ(variant.Compare(expected_variant), 0);
191 }
192 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleI1)193 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleI1) {
194   VariantVector vector;
195   ScopedVariant expected_variant;
196 
197   expected_variant.Set((int8_t)34);
198   vector.Insert<VT_I1>(34);
199   EXPECT_EQ(vector.Type(), expected_variant.type());
200   EXPECT_EQ(vector.Size(), 1U);
201 
202   ScopedVariant variant(vector.ReleaseAsScalarVariant());
203   EXPECT_EQ(vector.Type(), VT_EMPTY);
204   EXPECT_EQ(vector.Size(), 0U);
205   EXPECT_EQ(variant.Compare(expected_variant), 0);
206 }
207 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleUI1)208 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleUI1) {
209   VariantVector vector;
210   ScopedVariant expected_variant;
211 
212   expected_variant.Set((uint8_t)35U);
213   vector.Insert<VT_UI1>(35U);
214   EXPECT_EQ(vector.Type(), expected_variant.type());
215   EXPECT_EQ(vector.Size(), 1U);
216 
217   ScopedVariant variant(vector.ReleaseAsScalarVariant());
218   EXPECT_EQ(vector.Type(), VT_EMPTY);
219   EXPECT_EQ(vector.Size(), 0U);
220   EXPECT_EQ(variant.Compare(expected_variant), 0);
221 }
222 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleI2)223 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleI2) {
224   VariantVector vector;
225   ScopedVariant expected_variant;
226 
227   expected_variant.Set((int16_t)8738);
228   vector.Insert<VT_I2>(8738);
229   EXPECT_EQ(vector.Type(), expected_variant.type());
230   EXPECT_EQ(vector.Size(), 1U);
231 
232   ScopedVariant variant(vector.ReleaseAsScalarVariant());
233   EXPECT_EQ(vector.Type(), VT_EMPTY);
234   EXPECT_EQ(vector.Size(), 0U);
235   EXPECT_EQ(variant.Compare(expected_variant), 0);
236 }
237 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleUI2)238 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleUI2) {
239   VariantVector vector;
240   ScopedVariant expected_variant;
241 
242   expected_variant.Set((uint16_t)8739U);
243   vector.Insert<VT_UI2>(8739U);
244   EXPECT_EQ(vector.Type(), expected_variant.type());
245   EXPECT_EQ(vector.Size(), 1U);
246 
247   ScopedVariant variant(vector.ReleaseAsScalarVariant());
248   EXPECT_EQ(vector.Type(), VT_EMPTY);
249   EXPECT_EQ(vector.Size(), 0U);
250   EXPECT_EQ(variant.Compare(expected_variant), 0);
251 }
252 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleI4)253 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleI4) {
254   VariantVector vector;
255   ScopedVariant expected_variant;
256 
257   expected_variant.Set((int32_t)572662306);
258   vector.Insert<VT_I4>(572662306);
259   EXPECT_EQ(vector.Type(), expected_variant.type());
260   EXPECT_EQ(vector.Size(), 1U);
261 
262   ScopedVariant variant(vector.ReleaseAsScalarVariant());
263   EXPECT_EQ(vector.Type(), VT_EMPTY);
264   EXPECT_EQ(vector.Size(), 0U);
265   EXPECT_EQ(variant.Compare(expected_variant), 0);
266 }
267 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleUI4)268 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleUI4) {
269   VariantVector vector;
270   ScopedVariant expected_variant;
271 
272   expected_variant.Set((uint32_t)572662307U);
273   vector.Insert<VT_UI4>(572662307U);
274   EXPECT_EQ(vector.Type(), expected_variant.type());
275   EXPECT_EQ(vector.Size(), 1U);
276 
277   ScopedVariant variant(vector.ReleaseAsScalarVariant());
278   EXPECT_EQ(vector.Type(), VT_EMPTY);
279   EXPECT_EQ(vector.Size(), 0U);
280   EXPECT_EQ(variant.Compare(expected_variant), 0);
281 }
282 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleI8)283 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleI8) {
284   VariantVector vector;
285   ScopedVariant expected_variant;
286 
287   expected_variant.Set((int64_t)2459565876494606882);
288   vector.Insert<VT_I8>(2459565876494606882);
289   EXPECT_EQ(vector.Type(), expected_variant.type());
290   EXPECT_EQ(vector.Size(), 1U);
291 
292   ScopedVariant variant(vector.ReleaseAsScalarVariant());
293   EXPECT_EQ(vector.Type(), VT_EMPTY);
294   EXPECT_EQ(vector.Size(), 0U);
295   EXPECT_EQ(variant.Compare(expected_variant), 0);
296 }
297 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleUI8)298 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleUI8) {
299   VariantVector vector;
300   ScopedVariant expected_variant;
301 
302   expected_variant.Set((uint64_t)2459565876494606883U);
303   vector.Insert<VT_UI8>(2459565876494606883U);
304   EXPECT_EQ(vector.Type(), expected_variant.type());
305   EXPECT_EQ(vector.Size(), 1U);
306 
307   ScopedVariant variant(vector.ReleaseAsScalarVariant());
308   EXPECT_EQ(vector.Type(), VT_EMPTY);
309   EXPECT_EQ(vector.Size(), 0U);
310   EXPECT_EQ(variant.Compare(expected_variant), 0);
311 }
312 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleR4)313 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleR4) {
314   VariantVector vector;
315   ScopedVariant expected_variant;
316 
317   expected_variant.Set(3.14159f);
318   vector.Insert<VT_R4>(3.14159f);
319   EXPECT_EQ(vector.Type(), expected_variant.type());
320   EXPECT_EQ(vector.Size(), 1U);
321 
322   ScopedVariant variant(vector.ReleaseAsScalarVariant());
323   EXPECT_EQ(vector.Type(), VT_EMPTY);
324   EXPECT_EQ(vector.Size(), 0U);
325   EXPECT_EQ(variant.Compare(expected_variant), 0);
326 }
327 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleR8)328 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleR8) {
329   VariantVector vector;
330   ScopedVariant expected_variant;
331 
332   expected_variant.Set(6.28318);
333   vector.Insert<VT_R8>(6.28318);
334   EXPECT_EQ(vector.Type(), expected_variant.type());
335   EXPECT_EQ(vector.Size(), 1U);
336 
337   ScopedVariant variant(vector.ReleaseAsScalarVariant());
338   EXPECT_EQ(vector.Type(), VT_EMPTY);
339   EXPECT_EQ(vector.Size(), 0U);
340   EXPECT_EQ(variant.Compare(expected_variant), 0);
341 }
342 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleDate)343 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleDate) {
344   VariantVector vector;
345   ScopedVariant expected_variant;
346 
347   SYSTEMTIME sys_time;
348   ::GetSystemTime(&sys_time);
349   DATE date;
350   ::SystemTimeToVariantTime(&sys_time, &date);
351   expected_variant.SetDate(date);
352   vector.Insert<VT_DATE>(date);
353   EXPECT_EQ(vector.Type(), expected_variant.type());
354   EXPECT_EQ(vector.Size(), 1U);
355 
356   ScopedVariant variant(vector.ReleaseAsScalarVariant());
357   EXPECT_EQ(vector.Type(), VT_EMPTY);
358   EXPECT_EQ(vector.Size(), 0U);
359   EXPECT_EQ(variant.Compare(expected_variant), 0);
360 }
361 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleBstr)362 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleBstr) {
363   VariantVector vector;
364   ScopedVariant expected_variant;
365 
366   wchar_t test_string[] = L"Test string for BSTRs.";
367   expected_variant.Set(test_string);
368   vector.Insert<VT_BSTR>(test_string);
369   EXPECT_EQ(vector.Type(), expected_variant.type());
370   EXPECT_EQ(vector.Size(), 1U);
371 
372   ScopedVariant variant(vector.ReleaseAsScalarVariant());
373   EXPECT_EQ(vector.Type(), VT_EMPTY);
374   EXPECT_EQ(vector.Size(), 0U);
375   EXPECT_EQ(variant.Compare(expected_variant), 0);
376 }
377 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleUnknown)378 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleUnknown) {
379   VariantVector vector;
380   ScopedVariant expected_variant;
381 
382   Microsoft::WRL::ComPtr<IUnknown> unknown =
383       Microsoft::WRL::Make<DispatchStub>();
384   expected_variant.Set(unknown.Get());
385   vector.Insert<VT_UNKNOWN>(unknown.Get());
386   EXPECT_EQ(vector.Type(), expected_variant.type());
387   EXPECT_EQ(vector.Size(), 1U);
388 
389   ScopedVariant variant(vector.ReleaseAsScalarVariant());
390   EXPECT_EQ(vector.Type(), VT_EMPTY);
391   EXPECT_EQ(vector.Size(), 0U);
392   EXPECT_EQ(variant.Compare(expected_variant), 0);
393 }
394 
TEST(VariantVectorTest,ReleaseAsScalarVariantSingleDispatch)395 TEST(VariantVectorTest, ReleaseAsScalarVariantSingleDispatch) {
396   VariantVector vector;
397   ScopedVariant expected_variant;
398 
399   Microsoft::WRL::ComPtr<IDispatch> dispatch =
400       Microsoft::WRL::Make<DispatchStub>();
401   expected_variant.Set(dispatch.Get());
402   vector.Insert<VT_DISPATCH>(dispatch.Get());
403   EXPECT_EQ(vector.Type(), expected_variant.type());
404   EXPECT_EQ(vector.Size(), 1U);
405 
406   ScopedVariant variant(vector.ReleaseAsScalarVariant());
407   EXPECT_EQ(vector.Type(), VT_EMPTY);
408   EXPECT_EQ(vector.Size(), 0U);
409   EXPECT_EQ(variant.Compare(expected_variant), 0);
410 }
411 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleBool)412 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleBool) {
413   constexpr VARTYPE kVariantType = VT_BOOL;
414   VariantVector vector;
415   ScopedVariant variant;
416 
417   vector.Insert<kVariantType>(true);
418   vector.Insert<kVariantType>(false);
419   EXPECT_EQ(vector.Type(), kVariantType);
420   EXPECT_EQ(vector.Size(), 2U);
421   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
422 }
423 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleI1)424 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleI1) {
425   constexpr VARTYPE kVariantType = VT_I1;
426   VariantVector vector;
427   ScopedVariant variant;
428 
429   vector.Insert<kVariantType>(34);
430   vector.Insert<kVariantType>(52);
431   EXPECT_EQ(vector.Type(), kVariantType);
432   EXPECT_EQ(vector.Size(), 2U);
433   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
434 }
435 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleUI1)436 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleUI1) {
437   constexpr VARTYPE kVariantType = VT_UI1;
438   VariantVector vector;
439   ScopedVariant variant;
440 
441   vector.Insert<kVariantType>(34U);
442   vector.Insert<kVariantType>(52U);
443   EXPECT_EQ(vector.Type(), kVariantType);
444   EXPECT_EQ(vector.Size(), 2U);
445   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
446 }
447 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleI2)448 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleI2) {
449   constexpr VARTYPE kVariantType = VT_I2;
450   VariantVector vector;
451   ScopedVariant variant;
452 
453   vector.Insert<kVariantType>(8738);
454   vector.Insert<kVariantType>(8758);
455   EXPECT_EQ(vector.Type(), kVariantType);
456   EXPECT_EQ(vector.Size(), 2U);
457   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
458 }
459 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleUI2)460 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleUI2) {
461   constexpr VARTYPE kVariantType = VT_UI2;
462   VariantVector vector;
463   ScopedVariant variant;
464 
465   vector.Insert<kVariantType>(8739U);
466   vector.Insert<kVariantType>(8759U);
467   EXPECT_EQ(vector.Type(), kVariantType);
468   EXPECT_EQ(vector.Size(), 2U);
469   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
470 }
471 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleI4)472 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleI4) {
473   constexpr VARTYPE kVariantType = VT_I4;
474   VariantVector vector;
475   ScopedVariant variant;
476 
477   vector.Insert<kVariantType>(572662306);
478   vector.Insert<kVariantType>(572662307);
479   EXPECT_EQ(vector.Type(), kVariantType);
480   EXPECT_EQ(vector.Size(), 2U);
481   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
482 }
483 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleUI4)484 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleUI4) {
485   constexpr VARTYPE kVariantType = VT_UI4;
486   VariantVector vector;
487   ScopedVariant variant;
488 
489   vector.Insert<kVariantType>(578662306U);
490   vector.Insert<kVariantType>(578662307U);
491   EXPECT_EQ(vector.Type(), kVariantType);
492   EXPECT_EQ(vector.Size(), 2U);
493   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
494 }
495 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleI8)496 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleI8) {
497   constexpr VARTYPE kVariantType = VT_I8;
498   VariantVector vector;
499   ScopedVariant variant;
500 
501   vector.Insert<kVariantType>(2459565876494606882);
502   vector.Insert<kVariantType>(2459565876494606883);
503   EXPECT_EQ(vector.Type(), kVariantType);
504   EXPECT_EQ(vector.Size(), 2U);
505   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
506 }
507 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleUI8)508 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleUI8) {
509   constexpr VARTYPE kVariantType = VT_UI8;
510   VariantVector vector;
511   ScopedVariant variant;
512 
513   vector.Insert<kVariantType>(2459565876494606883U);
514   vector.Insert<kVariantType>(2459565876494606884U);
515   EXPECT_EQ(vector.Type(), kVariantType);
516   EXPECT_EQ(vector.Size(), 2U);
517   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
518 }
519 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleR4)520 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleR4) {
521   constexpr VARTYPE kVariantType = VT_R4;
522   VariantVector vector;
523   ScopedVariant variant;
524 
525   vector.Insert<kVariantType>(3.14159f);
526   vector.Insert<kVariantType>(6.28318f);
527   EXPECT_EQ(vector.Type(), kVariantType);
528   EXPECT_EQ(vector.Size(), 2U);
529   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
530 }
531 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleR8)532 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleR8) {
533   constexpr VARTYPE kVariantType = VT_R8;
534   VariantVector vector;
535   ScopedVariant variant;
536 
537   vector.Insert<kVariantType>(6.28318);
538   vector.Insert<kVariantType>(3.14159);
539   EXPECT_EQ(vector.Type(), kVariantType);
540   EXPECT_EQ(vector.Size(), 2U);
541   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
542 }
543 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleDate)544 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleDate) {
545   constexpr VARTYPE kVariantType = VT_DATE;
546   VariantVector vector;
547   ScopedVariant variant;
548 
549   SYSTEMTIME sys_time;
550   ::GetSystemTime(&sys_time);
551   DATE date;
552   ::SystemTimeToVariantTime(&sys_time, &date);
553 
554   vector.Insert<kVariantType>(date);
555   vector.Insert<kVariantType>(date);
556   EXPECT_EQ(vector.Type(), kVariantType);
557   EXPECT_EQ(vector.Size(), 2U);
558   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
559 }
560 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleBstr)561 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleBstr) {
562   constexpr VARTYPE kVariantType = VT_BSTR;
563   VariantVector vector;
564   ScopedVariant variant;
565 
566   wchar_t some_text[] = L"some text";
567   wchar_t more_text[] = L"more text";
568   vector.Insert<kVariantType>(some_text);
569   vector.Insert<kVariantType>(more_text);
570   EXPECT_EQ(vector.Type(), kVariantType);
571   EXPECT_EQ(vector.Size(), 2U);
572   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
573 }
574 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleUnknown)575 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleUnknown) {
576   constexpr VARTYPE kVariantType = VT_UNKNOWN;
577   VariantVector vector;
578   ScopedVariant variant;
579 
580   Microsoft::WRL::ComPtr<IUnknown> unknown1 =
581       Microsoft::WRL::Make<DispatchStub>();
582   Microsoft::WRL::ComPtr<IUnknown> unknown2 =
583       Microsoft::WRL::Make<DispatchStub>();
584 
585   vector.Insert<kVariantType>(unknown1.Get());
586   vector.Insert<kVariantType>(unknown2.Get());
587   EXPECT_EQ(vector.Type(), kVariantType);
588   EXPECT_EQ(vector.Size(), 2U);
589   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
590 }
591 
TEST(VariantVectorTest,ReleaseAsScalarVariantMultipleDispatch)592 TEST(VariantVectorTest, ReleaseAsScalarVariantMultipleDispatch) {
593   constexpr VARTYPE kVariantType = VT_DISPATCH;
594   VariantVector vector;
595   ScopedVariant variant;
596 
597   Microsoft::WRL::ComPtr<IDispatch> dispatch1 =
598       Microsoft::WRL::Make<DispatchStub>();
599   Microsoft::WRL::ComPtr<IDispatch> dispatch2 =
600       Microsoft::WRL::Make<DispatchStub>();
601 
602   vector.Insert<kVariantType>(dispatch1.Get());
603   vector.Insert<kVariantType>(dispatch2.Get());
604   EXPECT_EQ(vector.Type(), kVariantType);
605   EXPECT_EQ(vector.Size(), 2U);
606   EXPECT_DCHECK_DEATH(vector.ReleaseAsScalarVariant());
607 }
608 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantEmpty)609 TEST(VariantVectorTest, ReleaseAsSafearrayVariantEmpty) {
610   VariantVector vector;
611   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
612   EXPECT_EQ(variant.type(), VT_EMPTY);
613 }
614 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleBool)615 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleBool) {
616   constexpr VARTYPE kVariantType = VT_BOOL;
617   VariantVector vector;
618 
619   vector.Insert<kVariantType>(true);
620   EXPECT_EQ(vector.Type(), kVariantType);
621   EXPECT_EQ(vector.Size(), 1U);
622 
623   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
624   EXPECT_EQ(vector.Type(), VT_EMPTY);
625   EXPECT_EQ(vector.Size(), 0U);
626   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
627 
628   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
629   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
630       safearray.CreateLockScope<kVariantType>();
631   ASSERT_TRUE(lock_scope.has_value());
632   ASSERT_EQ(lock_scope->size(), 1U);
633   EXPECT_EQ(lock_scope->at(0), VARIANT_TRUE);
634   safearray.Release();
635 }
636 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleI1)637 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleI1) {
638   constexpr VARTYPE kVariantType = VT_I1;
639   VariantVector vector;
640 
641   vector.Insert<kVariantType>(34);
642   EXPECT_EQ(vector.Type(), kVariantType);
643   EXPECT_EQ(vector.Size(), 1U);
644 
645   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
646   EXPECT_EQ(vector.Type(), VT_EMPTY);
647   EXPECT_EQ(vector.Size(), 0U);
648   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
649 
650   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
651   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
652       safearray.CreateLockScope<kVariantType>();
653   ASSERT_TRUE(lock_scope.has_value());
654   ASSERT_EQ(lock_scope->size(), 1U);
655   EXPECT_EQ(lock_scope->at(0), 34);
656   safearray.Release();
657 }
658 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleUI1)659 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleUI1) {
660   constexpr VARTYPE kVariantType = VT_UI1;
661   VariantVector vector;
662 
663   vector.Insert<kVariantType>(34U);
664   EXPECT_EQ(vector.Type(), kVariantType);
665   EXPECT_EQ(vector.Size(), 1U);
666 
667   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
668   EXPECT_EQ(vector.Type(), VT_EMPTY);
669   EXPECT_EQ(vector.Size(), 0U);
670   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
671 
672   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
673   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
674       safearray.CreateLockScope<kVariantType>();
675   ASSERT_TRUE(lock_scope.has_value());
676   ASSERT_EQ(lock_scope->size(), 1U);
677   EXPECT_EQ(lock_scope->at(0), 34U);
678   safearray.Release();
679 }
680 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleI2)681 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleI2) {
682   constexpr VARTYPE kVariantType = VT_I2;
683   VariantVector vector;
684 
685   vector.Insert<kVariantType>(8738);
686   EXPECT_EQ(vector.Type(), kVariantType);
687   EXPECT_EQ(vector.Size(), 1U);
688 
689   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
690   EXPECT_EQ(vector.Type(), VT_EMPTY);
691   EXPECT_EQ(vector.Size(), 0U);
692   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
693 
694   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
695   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
696       safearray.CreateLockScope<kVariantType>();
697   ASSERT_TRUE(lock_scope.has_value());
698   ASSERT_EQ(lock_scope->size(), 1U);
699   EXPECT_EQ(lock_scope->at(0), 8738);
700   safearray.Release();
701 }
702 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleUI2)703 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleUI2) {
704   constexpr VARTYPE kVariantType = VT_UI2;
705   VariantVector vector;
706 
707   vector.Insert<kVariantType>(8739U);
708   EXPECT_EQ(vector.Type(), kVariantType);
709   EXPECT_EQ(vector.Size(), 1U);
710 
711   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
712   EXPECT_EQ(vector.Type(), VT_EMPTY);
713   EXPECT_EQ(vector.Size(), 0U);
714   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
715 
716   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
717   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
718       safearray.CreateLockScope<kVariantType>();
719   ASSERT_TRUE(lock_scope.has_value());
720   ASSERT_EQ(lock_scope->size(), 1U);
721   EXPECT_EQ(lock_scope->at(0), 8739U);
722   safearray.Release();
723 }
724 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleI4)725 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleI4) {
726   constexpr VARTYPE kVariantType = VT_I4;
727   VariantVector vector;
728 
729   vector.Insert<kVariantType>(572662306);
730   EXPECT_EQ(vector.Type(), kVariantType);
731   EXPECT_EQ(vector.Size(), 1U);
732 
733   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
734   EXPECT_EQ(vector.Type(), VT_EMPTY);
735   EXPECT_EQ(vector.Size(), 0U);
736   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
737 
738   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
739   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
740       safearray.CreateLockScope<kVariantType>();
741   ASSERT_TRUE(lock_scope.has_value());
742   ASSERT_EQ(lock_scope->size(), 1U);
743   EXPECT_EQ(lock_scope->at(0), 572662306);
744   safearray.Release();
745 }
746 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleUI4)747 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleUI4) {
748   constexpr VARTYPE kVariantType = VT_UI4;
749   VariantVector vector;
750 
751   vector.Insert<kVariantType>(578662306U);
752   EXPECT_EQ(vector.Type(), kVariantType);
753   EXPECT_EQ(vector.Size(), 1U);
754 
755   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
756   EXPECT_EQ(vector.Type(), VT_EMPTY);
757   EXPECT_EQ(vector.Size(), 0U);
758   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
759 
760   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
761   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
762       safearray.CreateLockScope<kVariantType>();
763   ASSERT_TRUE(lock_scope.has_value());
764   ASSERT_EQ(lock_scope->size(), 1U);
765   EXPECT_EQ(lock_scope->at(0), 578662306U);
766   safearray.Release();
767 }
768 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleI8)769 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleI8) {
770   constexpr VARTYPE kVariantType = VT_I8;
771   VariantVector vector;
772 
773   vector.Insert<kVariantType>(2459565876494606882);
774   EXPECT_EQ(vector.Type(), kVariantType);
775   EXPECT_EQ(vector.Size(), 1U);
776 
777   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
778   EXPECT_EQ(vector.Type(), VT_EMPTY);
779   EXPECT_EQ(vector.Size(), 0U);
780   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
781 
782   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
783   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
784       safearray.CreateLockScope<kVariantType>();
785   ASSERT_TRUE(lock_scope.has_value());
786   ASSERT_EQ(lock_scope->size(), 1U);
787   EXPECT_EQ(lock_scope->at(0), 2459565876494606882);
788   safearray.Release();
789 }
790 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleUI8)791 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleUI8) {
792   constexpr VARTYPE kVariantType = VT_UI8;
793   VariantVector vector;
794 
795   vector.Insert<kVariantType>(2459565876494606883U);
796   EXPECT_EQ(vector.Type(), kVariantType);
797   EXPECT_EQ(vector.Size(), 1U);
798 
799   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
800   EXPECT_EQ(vector.Type(), VT_EMPTY);
801   EXPECT_EQ(vector.Size(), 0U);
802   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
803 
804   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
805   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
806       safearray.CreateLockScope<kVariantType>();
807   ASSERT_TRUE(lock_scope.has_value());
808   ASSERT_EQ(lock_scope->size(), 1U);
809   EXPECT_EQ(lock_scope->at(0), 2459565876494606883U);
810   safearray.Release();
811 }
812 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleR4)813 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleR4) {
814   constexpr VARTYPE kVariantType = VT_R4;
815   VariantVector vector;
816 
817   vector.Insert<kVariantType>(3.14159f);
818   EXPECT_EQ(vector.Type(), kVariantType);
819   EXPECT_EQ(vector.Size(), 1U);
820 
821   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
822   EXPECT_EQ(vector.Type(), VT_EMPTY);
823   EXPECT_EQ(vector.Size(), 0U);
824   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
825 
826   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
827   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
828       safearray.CreateLockScope<kVariantType>();
829   ASSERT_TRUE(lock_scope.has_value());
830   ASSERT_EQ(lock_scope->size(), 1U);
831   EXPECT_EQ(lock_scope->at(0), 3.14159f);
832   safearray.Release();
833 }
834 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleR8)835 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleR8) {
836   constexpr VARTYPE kVariantType = VT_R8;
837   VariantVector vector;
838 
839   vector.Insert<kVariantType>(6.28318);
840   EXPECT_EQ(vector.Type(), kVariantType);
841   EXPECT_EQ(vector.Size(), 1U);
842 
843   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
844   EXPECT_EQ(vector.Type(), VT_EMPTY);
845   EXPECT_EQ(vector.Size(), 0U);
846   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
847 
848   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
849   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
850       safearray.CreateLockScope<kVariantType>();
851   ASSERT_TRUE(lock_scope.has_value());
852   ASSERT_EQ(lock_scope->size(), 1U);
853   EXPECT_EQ(lock_scope->at(0), 6.28318);
854   safearray.Release();
855 }
856 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleDate)857 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleDate) {
858   constexpr VARTYPE kVariantType = VT_DATE;
859   VariantVector vector;
860 
861   SYSTEMTIME sys_time;
862   ::GetSystemTime(&sys_time);
863   DATE date;
864   ::SystemTimeToVariantTime(&sys_time, &date);
865 
866   vector.Insert<kVariantType>(date);
867   EXPECT_EQ(vector.Type(), kVariantType);
868   EXPECT_EQ(vector.Size(), 1U);
869 
870   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
871   EXPECT_EQ(vector.Type(), VT_EMPTY);
872   EXPECT_EQ(vector.Size(), 0U);
873   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
874 
875   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
876   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
877       safearray.CreateLockScope<kVariantType>();
878   ASSERT_TRUE(lock_scope.has_value());
879   ASSERT_EQ(lock_scope->size(), 1U);
880   EXPECT_EQ(lock_scope->at(0), date);
881   safearray.Release();
882 }
883 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleBstr)884 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleBstr) {
885   constexpr VARTYPE kVariantType = VT_BSTR;
886   VariantVector vector;
887 
888   wchar_t some_text[] = L"some text";
889   vector.Insert<kVariantType>(some_text);
890   EXPECT_EQ(vector.Type(), kVariantType);
891   EXPECT_EQ(vector.Size(), 1U);
892 
893   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
894   EXPECT_EQ(vector.Type(), VT_EMPTY);
895   EXPECT_EQ(vector.Size(), 0U);
896   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
897 
898   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
899   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
900       safearray.CreateLockScope<kVariantType>();
901   ASSERT_TRUE(lock_scope.has_value());
902   ASSERT_EQ(lock_scope->size(), 1U);
903   EXPECT_STREQ(lock_scope->at(0), some_text);
904   safearray.Release();
905 }
906 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleUnknown)907 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleUnknown) {
908   constexpr VARTYPE kVariantType = VT_UNKNOWN;
909   VariantVector vector;
910 
911   Microsoft::WRL::ComPtr<IUnknown> unknown =
912       Microsoft::WRL::Make<DispatchStub>();
913 
914   vector.Insert<kVariantType>(unknown.Get());
915   EXPECT_EQ(vector.Type(), kVariantType);
916   EXPECT_EQ(vector.Size(), 1U);
917 
918   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
919   EXPECT_EQ(vector.Type(), VT_EMPTY);
920   EXPECT_EQ(vector.Size(), 0U);
921   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
922 
923   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
924   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
925       safearray.CreateLockScope<kVariantType>();
926   ASSERT_TRUE(lock_scope.has_value());
927   ASSERT_EQ(lock_scope->size(), 1U);
928   EXPECT_EQ(lock_scope->at(0), unknown.Get());
929   safearray.Release();
930 }
931 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantSingleDispatch)932 TEST(VariantVectorTest, ReleaseAsSafearrayVariantSingleDispatch) {
933   constexpr VARTYPE kVariantType = VT_DISPATCH;
934   VariantVector vector;
935 
936   Microsoft::WRL::ComPtr<IDispatch> dispatch =
937       Microsoft::WRL::Make<DispatchStub>();
938 
939   vector.Insert<kVariantType>(dispatch.Get());
940   EXPECT_EQ(vector.Type(), kVariantType);
941   EXPECT_EQ(vector.Size(), 1U);
942 
943   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
944   EXPECT_EQ(vector.Type(), VT_EMPTY);
945   EXPECT_EQ(vector.Size(), 0U);
946   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
947 
948   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
949   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
950       safearray.CreateLockScope<kVariantType>();
951   ASSERT_TRUE(lock_scope.has_value());
952   ASSERT_EQ(lock_scope->size(), 1U);
953   EXPECT_EQ(lock_scope->at(0), dispatch.Get());
954   safearray.Release();
955 }
956 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleBool)957 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleBool) {
958   constexpr VARTYPE kVariantType = VT_BOOL;
959   VariantVector vector;
960 
961   vector.Insert<kVariantType>(true);
962   vector.Insert<kVariantType>(false);
963   vector.Insert<kVariantType>(true);
964   EXPECT_EQ(vector.Type(), kVariantType);
965   EXPECT_EQ(vector.Size(), 3U);
966 
967   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
968   EXPECT_EQ(vector.Type(), VT_EMPTY);
969   EXPECT_EQ(vector.Size(), 0U);
970   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
971 
972   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
973   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
974       safearray.CreateLockScope<kVariantType>();
975   ASSERT_TRUE(lock_scope.has_value());
976   ASSERT_EQ(lock_scope->size(), 3U);
977   EXPECT_EQ(lock_scope->at(0), VARIANT_TRUE);
978   EXPECT_EQ(lock_scope->at(1), VARIANT_FALSE);
979   EXPECT_EQ(lock_scope->at(2), VARIANT_TRUE);
980   safearray.Release();
981 }
982 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleI1)983 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleI1) {
984   constexpr VARTYPE kVariantType = VT_I1;
985   VariantVector vector;
986 
987   vector.Insert<kVariantType>(34);
988   vector.Insert<kVariantType>(52);
989   vector.Insert<kVariantType>(12);
990   EXPECT_EQ(vector.Type(), kVariantType);
991   EXPECT_EQ(vector.Size(), 3U);
992 
993   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
994   EXPECT_EQ(vector.Type(), VT_EMPTY);
995   EXPECT_EQ(vector.Size(), 0U);
996   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
997 
998   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
999   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1000       safearray.CreateLockScope<kVariantType>();
1001   ASSERT_TRUE(lock_scope.has_value());
1002   ASSERT_EQ(lock_scope->size(), 3U);
1003   EXPECT_EQ(lock_scope->at(0), 34);
1004   EXPECT_EQ(lock_scope->at(1), 52);
1005   EXPECT_EQ(lock_scope->at(2), 12);
1006   safearray.Release();
1007 }
1008 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleUI1)1009 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleUI1) {
1010   constexpr VARTYPE kVariantType = VT_UI1;
1011   VariantVector vector;
1012 
1013   vector.Insert<kVariantType>(34U);
1014   vector.Insert<kVariantType>(52U);
1015   vector.Insert<kVariantType>(12U);
1016   EXPECT_EQ(vector.Type(), kVariantType);
1017   EXPECT_EQ(vector.Size(), 3U);
1018 
1019   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1020   EXPECT_EQ(vector.Type(), VT_EMPTY);
1021   EXPECT_EQ(vector.Size(), 0U);
1022   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1023 
1024   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1025   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1026       safearray.CreateLockScope<kVariantType>();
1027   ASSERT_TRUE(lock_scope.has_value());
1028   ASSERT_EQ(lock_scope->size(), 3U);
1029   EXPECT_EQ(lock_scope->at(0), 34U);
1030   EXPECT_EQ(lock_scope->at(1), 52U);
1031   EXPECT_EQ(lock_scope->at(2), 12U);
1032   safearray.Release();
1033 }
1034 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleI2)1035 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleI2) {
1036   constexpr VARTYPE kVariantType = VT_I2;
1037   VariantVector vector;
1038 
1039   vector.Insert<kVariantType>(8738);
1040   vector.Insert<kVariantType>(8758);
1041   vector.Insert<kVariantType>(42);
1042   EXPECT_EQ(vector.Type(), kVariantType);
1043   EXPECT_EQ(vector.Size(), 3U);
1044 
1045   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1046   EXPECT_EQ(vector.Type(), VT_EMPTY);
1047   EXPECT_EQ(vector.Size(), 0U);
1048   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1049 
1050   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1051   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1052       safearray.CreateLockScope<kVariantType>();
1053   ASSERT_TRUE(lock_scope.has_value());
1054   ASSERT_EQ(lock_scope->size(), 3U);
1055   EXPECT_EQ(lock_scope->at(0), 8738);
1056   EXPECT_EQ(lock_scope->at(1), 8758);
1057   EXPECT_EQ(lock_scope->at(2), 42);
1058   safearray.Release();
1059 }
1060 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleUI2)1061 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleUI2) {
1062   constexpr VARTYPE kVariantType = VT_UI2;
1063   VariantVector vector;
1064 
1065   vector.Insert<kVariantType>(8739U);
1066   vector.Insert<kVariantType>(8759U);
1067   vector.Insert<kVariantType>(42U);
1068   EXPECT_EQ(vector.Type(), kVariantType);
1069   EXPECT_EQ(vector.Size(), 3U);
1070 
1071   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1072   EXPECT_EQ(vector.Type(), VT_EMPTY);
1073   EXPECT_EQ(vector.Size(), 0U);
1074   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1075 
1076   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1077   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1078       safearray.CreateLockScope<kVariantType>();
1079   ASSERT_TRUE(lock_scope.has_value());
1080   ASSERT_EQ(lock_scope->size(), 3U);
1081   EXPECT_EQ(lock_scope->at(0), 8739U);
1082   EXPECT_EQ(lock_scope->at(1), 8759U);
1083   EXPECT_EQ(lock_scope->at(2), 42U);
1084   safearray.Release();
1085 }
1086 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleI4)1087 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleI4) {
1088   constexpr VARTYPE kVariantType = VT_I4;
1089   VariantVector vector;
1090 
1091   vector.Insert<kVariantType>(572662306);
1092   vector.Insert<kVariantType>(572662307);
1093   vector.Insert<kVariantType>(572662308);
1094   EXPECT_EQ(vector.Type(), kVariantType);
1095   EXPECT_EQ(vector.Size(), 3U);
1096 
1097   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1098   EXPECT_EQ(vector.Type(), VT_EMPTY);
1099   EXPECT_EQ(vector.Size(), 0U);
1100   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1101 
1102   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1103   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1104       safearray.CreateLockScope<kVariantType>();
1105   ASSERT_TRUE(lock_scope.has_value());
1106   ASSERT_EQ(lock_scope->size(), 3U);
1107   EXPECT_EQ(lock_scope->at(0), 572662306);
1108   EXPECT_EQ(lock_scope->at(1), 572662307);
1109   EXPECT_EQ(lock_scope->at(2), 572662308);
1110   safearray.Release();
1111 }
1112 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleUI4)1113 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleUI4) {
1114   constexpr VARTYPE kVariantType = VT_UI4;
1115   VariantVector vector;
1116 
1117   vector.Insert<kVariantType>(578662306U);
1118   vector.Insert<kVariantType>(578662307U);
1119   vector.Insert<kVariantType>(578662308U);
1120   EXPECT_EQ(vector.Type(), kVariantType);
1121   EXPECT_EQ(vector.Size(), 3U);
1122 
1123   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1124   EXPECT_EQ(vector.Type(), VT_EMPTY);
1125   EXPECT_EQ(vector.Size(), 0U);
1126   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1127 
1128   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1129   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1130       safearray.CreateLockScope<kVariantType>();
1131   ASSERT_TRUE(lock_scope.has_value());
1132   ASSERT_EQ(lock_scope->size(), 3U);
1133   EXPECT_EQ(lock_scope->at(0), 578662306U);
1134   EXPECT_EQ(lock_scope->at(1), 578662307U);
1135   EXPECT_EQ(lock_scope->at(2), 578662308U);
1136   safearray.Release();
1137 }
1138 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleI8)1139 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleI8) {
1140   constexpr VARTYPE kVariantType = VT_I8;
1141   VariantVector vector;
1142 
1143   vector.Insert<kVariantType>(2459565876494606882);
1144   vector.Insert<kVariantType>(2459565876494606883);
1145   vector.Insert<kVariantType>(2459565876494606884);
1146   EXPECT_EQ(vector.Type(), kVariantType);
1147   EXPECT_EQ(vector.Size(), 3U);
1148 
1149   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1150   EXPECT_EQ(vector.Type(), VT_EMPTY);
1151   EXPECT_EQ(vector.Size(), 0U);
1152   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1153 
1154   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1155   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1156       safearray.CreateLockScope<kVariantType>();
1157   ASSERT_TRUE(lock_scope.has_value());
1158   ASSERT_EQ(lock_scope->size(), 3U);
1159   EXPECT_EQ(lock_scope->at(0), 2459565876494606882);
1160   EXPECT_EQ(lock_scope->at(1), 2459565876494606883);
1161   EXPECT_EQ(lock_scope->at(2), 2459565876494606884);
1162   safearray.Release();
1163 }
1164 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleUI8)1165 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleUI8) {
1166   constexpr VARTYPE kVariantType = VT_UI8;
1167   VariantVector vector;
1168 
1169   vector.Insert<kVariantType>(2459565876494606883U);
1170   vector.Insert<kVariantType>(2459565876494606884U);
1171   vector.Insert<kVariantType>(2459565876494606885U);
1172   EXPECT_EQ(vector.Type(), kVariantType);
1173   EXPECT_EQ(vector.Size(), 3U);
1174 
1175   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1176   EXPECT_EQ(vector.Type(), VT_EMPTY);
1177   EXPECT_EQ(vector.Size(), 0U);
1178   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1179 
1180   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1181   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1182       safearray.CreateLockScope<kVariantType>();
1183   ASSERT_TRUE(lock_scope.has_value());
1184   ASSERT_EQ(lock_scope->size(), 3U);
1185   EXPECT_EQ(lock_scope->at(0), 2459565876494606883U);
1186   EXPECT_EQ(lock_scope->at(1), 2459565876494606884U);
1187   EXPECT_EQ(lock_scope->at(2), 2459565876494606885U);
1188   safearray.Release();
1189 }
1190 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleR4)1191 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleR4) {
1192   constexpr VARTYPE kVariantType = VT_R4;
1193   VariantVector vector;
1194 
1195   vector.Insert<kVariantType>(3.14159f);
1196   vector.Insert<kVariantType>(6.28318f);
1197   EXPECT_EQ(vector.Type(), kVariantType);
1198   EXPECT_EQ(vector.Size(), 2U);
1199 
1200   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1201   EXPECT_EQ(vector.Type(), VT_EMPTY);
1202   EXPECT_EQ(vector.Size(), 0U);
1203   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1204 
1205   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1206   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1207       safearray.CreateLockScope<kVariantType>();
1208   ASSERT_TRUE(lock_scope.has_value());
1209   ASSERT_EQ(lock_scope->size(), 2U);
1210   EXPECT_EQ(lock_scope->at(0), 3.14159f);
1211   EXPECT_EQ(lock_scope->at(1), 6.28318f);
1212   safearray.Release();
1213 }
1214 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleR8)1215 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleR8) {
1216   constexpr VARTYPE kVariantType = VT_R8;
1217   VariantVector vector;
1218 
1219   vector.Insert<kVariantType>(6.28318);
1220   vector.Insert<kVariantType>(3.14159);
1221   EXPECT_EQ(vector.Type(), kVariantType);
1222   EXPECT_EQ(vector.Size(), 2U);
1223 
1224   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1225   EXPECT_EQ(vector.Type(), VT_EMPTY);
1226   EXPECT_EQ(vector.Size(), 0U);
1227   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1228 
1229   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1230   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1231       safearray.CreateLockScope<kVariantType>();
1232   ASSERT_TRUE(lock_scope.has_value());
1233   ASSERT_EQ(lock_scope->size(), 2U);
1234   EXPECT_EQ(lock_scope->at(0), 6.28318);
1235   EXPECT_EQ(lock_scope->at(1), 3.14159);
1236   safearray.Release();
1237 }
1238 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleDate)1239 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleDate) {
1240   constexpr VARTYPE kVariantType = VT_DATE;
1241   VariantVector vector;
1242   SYSTEMTIME sys_time;
1243   ::GetSystemTime(&sys_time);
1244   DATE date;
1245   ::SystemTimeToVariantTime(&sys_time, &date);
1246 
1247   vector.Insert<kVariantType>(date);
1248   vector.Insert<kVariantType>(date);
1249   EXPECT_EQ(vector.Type(), kVariantType);
1250   EXPECT_EQ(vector.Size(), 2U);
1251 
1252   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1253   EXPECT_EQ(vector.Type(), VT_EMPTY);
1254   EXPECT_EQ(vector.Size(), 0U);
1255   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1256 
1257   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1258   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1259       safearray.CreateLockScope<kVariantType>();
1260   ASSERT_TRUE(lock_scope.has_value());
1261   ASSERT_EQ(lock_scope->size(), 2U);
1262   EXPECT_EQ(lock_scope->at(0), date);
1263   EXPECT_EQ(lock_scope->at(1), date);
1264   safearray.Release();
1265 }
1266 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleBstr)1267 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleBstr) {
1268   constexpr VARTYPE kVariantType = VT_BSTR;
1269   VariantVector vector;
1270   wchar_t some_text[] = L"some text";
1271   wchar_t more_text[] = L"more text";
1272   vector.Insert<kVariantType>(some_text);
1273   vector.Insert<kVariantType>(more_text);
1274   EXPECT_EQ(vector.Type(), kVariantType);
1275   EXPECT_EQ(vector.Size(), 2U);
1276 
1277   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1278   EXPECT_EQ(vector.Type(), VT_EMPTY);
1279   EXPECT_EQ(vector.Size(), 0U);
1280   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1281 
1282   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1283   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1284       safearray.CreateLockScope<kVariantType>();
1285   ASSERT_TRUE(lock_scope.has_value());
1286   ASSERT_EQ(lock_scope->size(), 2U);
1287   EXPECT_STREQ(lock_scope->at(0), some_text);
1288   EXPECT_STREQ(lock_scope->at(1), more_text);
1289   safearray.Release();
1290 }
1291 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleUnknown)1292 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleUnknown) {
1293   constexpr VARTYPE kVariantType = VT_UNKNOWN;
1294   VariantVector vector;
1295 
1296   Microsoft::WRL::ComPtr<IUnknown> unknown1 =
1297       Microsoft::WRL::Make<DispatchStub>();
1298   Microsoft::WRL::ComPtr<IUnknown> unknown2 =
1299       Microsoft::WRL::Make<DispatchStub>();
1300 
1301   vector.Insert<kVariantType>(unknown1.Get());
1302   vector.Insert<kVariantType>(unknown2.Get());
1303   EXPECT_EQ(vector.Type(), kVariantType);
1304   EXPECT_EQ(vector.Size(), 2U);
1305 
1306   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1307   EXPECT_EQ(vector.Type(), VT_EMPTY);
1308   EXPECT_EQ(vector.Size(), 0U);
1309   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1310 
1311   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1312   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1313       safearray.CreateLockScope<kVariantType>();
1314   ASSERT_TRUE(lock_scope.has_value());
1315   ASSERT_EQ(lock_scope->size(), 2U);
1316   EXPECT_EQ(lock_scope->at(0), unknown1.Get());
1317   EXPECT_EQ(lock_scope->at(1), unknown2.Get());
1318   safearray.Release();
1319 }
1320 
TEST(VariantVectorTest,ReleaseAsSafearrayVariantMultipleDispatch)1321 TEST(VariantVectorTest, ReleaseAsSafearrayVariantMultipleDispatch) {
1322   constexpr VARTYPE kVariantType = VT_DISPATCH;
1323   VariantVector vector;
1324 
1325   Microsoft::WRL::ComPtr<IDispatch> dispatch1 =
1326       Microsoft::WRL::Make<DispatchStub>();
1327   Microsoft::WRL::ComPtr<IDispatch> dispatch2 =
1328       Microsoft::WRL::Make<DispatchStub>();
1329 
1330   vector.Insert<kVariantType>(dispatch1.Get());
1331   vector.Insert<kVariantType>(dispatch2.Get());
1332   EXPECT_EQ(vector.Type(), kVariantType);
1333   EXPECT_EQ(vector.Size(), 2U);
1334 
1335   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1336   EXPECT_EQ(vector.Type(), VT_EMPTY);
1337   EXPECT_EQ(vector.Size(), 0U);
1338   EXPECT_EQ(variant.type(), VT_ARRAY | kVariantType);
1339 
1340   ScopedSafearray safearray(V_ARRAY(variant.ptr()));
1341   absl::optional<ScopedSafearray::LockScope<kVariantType>> lock_scope =
1342       safearray.CreateLockScope<kVariantType>();
1343   ASSERT_TRUE(lock_scope.has_value());
1344   ASSERT_EQ(lock_scope->size(), 2U);
1345   EXPECT_EQ(lock_scope->at(0), dispatch1.Get());
1346   EXPECT_EQ(lock_scope->at(1), dispatch2.Get());
1347   safearray.Release();
1348 }
1349 
TEST(VariantVectorTest,CompareVariant)1350 TEST(VariantVectorTest, CompareVariant) {
1351   VariantVector vector;
1352   ScopedVariant variant;
1353   EXPECT_EQ(vector.Compare(variant), 0);
1354 
1355   vector.Insert<VT_I4>(123);
1356   EXPECT_EQ(vector.Type(), VT_I4);
1357   EXPECT_EQ(vector.Size(), 1U);
1358 
1359   variant.Set(123);
1360   EXPECT_EQ(vector.Compare(variant), 0);
1361   variant.Set(4);
1362   EXPECT_EQ(vector.Compare(variant), 1);
1363   variant.Set(567);
1364   EXPECT_EQ(vector.Compare(variant), -1);
1365   // Because the types do not match and VT_I4 is less-than VT_R8,
1366   // |vector| compares as less-than |variant|, even though the value
1367   // in |vector| is greater.
1368   variant.Set(1.0);
1369   EXPECT_EQ(variant.type(), VT_R8);
1370   EXPECT_LT(vector.Type(), variant.type());
1371   EXPECT_EQ(vector.Compare(variant), -1);
1372 
1373   vector.Insert<VT_I4>(456);
1374   EXPECT_EQ(vector.Size(), 2U);
1375 
1376   // The first element of |vector| is equal to |variant|, but |vector|
1377   // has more than one element so it is greater-than |variant|.
1378   variant.Set(123);
1379   EXPECT_EQ(vector.Compare(variant), 1);
1380   // The first element of |vector| is greater-than |variant|.
1381   variant.Set(5);
1382   EXPECT_EQ(vector.Compare(variant), 1);
1383   // The first element of |vector| is less-than |variant|.
1384   variant.Set(1000);
1385   EXPECT_EQ(vector.Compare(variant), -1);
1386 }
1387 
TEST(VariantVectorTest,CompareSafearray)1388 TEST(VariantVectorTest, CompareSafearray) {
1389   VariantVector vector;
1390   vector.Insert<VT_I4>(123);
1391   vector.Insert<VT_I4>(456);
1392   EXPECT_EQ(vector.Type(), VT_I4);
1393   EXPECT_EQ(vector.Size(), 2U);
1394 
1395   ScopedVariant variant(vector.ReleaseAsSafearrayVariant());
1396   EXPECT_EQ(variant.type(), VT_ARRAY | VT_I4);
1397   EXPECT_EQ(vector.Type(), VT_EMPTY);
1398   EXPECT_EQ(vector.Size(), 0U);
1399 
1400   // Because |vector| is now empty, it will compare as less-than the array.
1401   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), -1);
1402   EXPECT_EQ(vector.Compare(variant), -1);
1403 
1404   vector.Insert<VT_I4>(123);
1405   EXPECT_EQ(vector.Type(), VT_I4);
1406   EXPECT_EQ(vector.Size(), 1U);
1407   // |vector| has fewer elements than |variant|.
1408   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), -1);
1409   EXPECT_EQ(vector.Compare(variant), -1);
1410 
1411   vector.Insert<VT_I4>(456);
1412   EXPECT_EQ(vector.Type(), VT_I4);
1413   EXPECT_EQ(vector.Size(), 2U);
1414   // |vector| is now equal to |variant|.
1415   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), 0);
1416   EXPECT_EQ(vector.Compare(variant), 0);
1417 
1418   vector.Insert<VT_I4>(789);
1419   EXPECT_EQ(vector.Type(), VT_I4);
1420   EXPECT_EQ(vector.Size(), 3U);
1421   // |vector| contains |variant| but has more elements so
1422   // |vector| is now greater-than |variant|.
1423   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), 1);
1424   EXPECT_EQ(vector.Compare(variant), 1);
1425 
1426   vector.Reset();
1427   vector.Insert<VT_I4>(456);
1428   EXPECT_EQ(vector.Type(), VT_I4);
1429   EXPECT_EQ(vector.Size(), 1U);
1430   // |vector| has fewer elements than |variant|, but the first element in
1431   // |vector| compares as greater-than the first element in |variant|.
1432   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), 1);
1433   EXPECT_EQ(vector.Compare(variant), 1);
1434 
1435   vector.Reset();
1436   vector.Insert<VT_R8>(0.0);
1437   vector.Insert<VT_R8>(0.0);
1438   EXPECT_EQ(vector.Type(), VT_R8);
1439   // Because the types do not match and VT_R8 is greater-than VT_I4,
1440   // |vector| compares as greater-than |variant|, even though the values
1441   // in |vector| are less-than the values in |variant|.
1442   EXPECT_GT(VT_R8, VT_I4);
1443   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), 1);
1444   EXPECT_EQ(vector.Compare(variant), 1);
1445 
1446   vector.Reset();
1447   vector.Insert<VT_I2>(1000);
1448   vector.Insert<VT_I2>(1000);
1449   EXPECT_EQ(vector.Type(), VT_I2);
1450   // Because the types do not match and VT_I2 is less-than VT_I4,
1451   // |vector| compares as less-than |variant|, even though the values
1452   // in |vector| are greater-than the values in |variant|.
1453   EXPECT_LT(VT_I2, VT_I4);
1454   EXPECT_EQ(vector.Compare(V_ARRAY(variant.ptr())), -1);
1455   EXPECT_EQ(vector.Compare(variant), -1);
1456 }
1457 
TEST(VariantVectorTest,CompareVariantVector)1458 TEST(VariantVectorTest, CompareVariantVector) {
1459   VariantVector vector1, vector2;
1460   EXPECT_EQ(vector1.Compare(vector2), 0);
1461   EXPECT_EQ(vector1, vector2);
1462 
1463   vector1.Insert<VT_I4>(1);
1464   EXPECT_EQ(vector1.Compare(vector2), 1);
1465   EXPECT_EQ(vector2.Compare(vector1), -1);
1466   EXPECT_NE(vector1, vector2);
1467 
1468   vector2.Insert<VT_I4>(1);
1469   EXPECT_EQ(vector1.Compare(vector2), 0);
1470   EXPECT_EQ(vector2.Compare(vector1), 0);
1471   EXPECT_EQ(vector1, vector2);
1472 
1473   vector1.Insert<VT_I4>(1);
1474   EXPECT_EQ(vector1.Compare(vector2), 1);
1475   EXPECT_EQ(vector2.Compare(vector1), -1);
1476   EXPECT_NE(vector1, vector2);
1477 
1478   vector2.Insert<VT_I4>(2);
1479   EXPECT_EQ(vector1.Compare(vector2), -1);
1480   EXPECT_EQ(vector2.Compare(vector1), 1);
1481   EXPECT_NE(vector1, vector2);
1482 
1483   vector1.Reset();
1484   vector1.Insert<VT_I4>(10);
1485   vector2.Reset();
1486   vector2.Insert<VT_R8>(5.0);
1487   // Because the types do not match and VT_I4 is less-than VT_R8,
1488   // |vector1| compares as less-than |vector2|, even though the value
1489   // in |vector1| is greater.
1490   EXPECT_LT(vector1.Type(), vector2.Type());
1491   EXPECT_EQ(vector1.Compare(vector2), -1);
1492   EXPECT_EQ(vector2.Compare(vector1), 1);
1493   EXPECT_NE(vector1, vector2);
1494 }
1495 
1496 }  // namespace win
1497 }  // namespace base
1498