xref: /trunk/main/cppu/qa/test_any.cxx (revision 91144cd0085a7583d2099b982122deb2184ab956) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_cppu.hxx"
26 
27 #include "sal/config.h"
28 
29 #include <stdlib.h> // wntmsci10 does not like <cstdlib>
30 
31 #include "Enum1.hpp"
32 #include "Enum2.hpp"
33 #include "Exception1.hpp"
34 #include "Exception2.hpp"
35 #include "Exception2a.hpp"
36 #include "Exception2b.hpp"
37 #include "Interface1.hpp"
38 #include "Interface2.hpp"
39 #include "Interface2a.hpp"
40 #include "Interface2b.hpp"
41 #include "Interface3.hpp"
42 #include "Poly.hpp"
43 #include "Struct1.hpp"
44 #include "Struct2.hpp"
45 #include "Struct2a.hpp"
46 #include "Struct2b.hpp"
47 #include "boost/type_traits/is_same.hpp"
48 #include "com/sun/star/uno/Any.hxx"
49 #include "com/sun/star/uno/Reference.hxx"
50 #include "com/sun/star/uno/RuntimeException.hpp"
51 #include "com/sun/star/uno/Sequence.hxx"
52 #include "com/sun/star/uno/Type.hxx"
53 #include "com/sun/star/uno/XInterface.hpp"
54 #include "osl/diagnose.h"
55 #include "osl/interlck.h"
56 #include "rtl/string.h"
57 #include "rtl/ustring.h"
58 #include "rtl/ustring.hxx"
59 #include "sal/types.h"
60 #include "gtest/gtest.h"
61 
62 namespace {
63 
64 namespace css = com::sun::star;
65 
66 class Base {
67 public:
Base()68     Base(): m_count(0) {}
69 
acquire()70     void acquire() {
71         if (osl_incrementInterlockedCount(&m_count) == SAL_MAX_INT32) {
72             abort();
73         }
74     }
75 
release()76     void release() {
77         if (osl_decrementInterlockedCount(&m_count) == 0) {
78             delete this;
79         }
80     }
81 
82 protected:
~Base()83     virtual ~Base() {}
84 
85 private:
86     Base(Base &); // not declared
87     void operator =(Base &); // not declared
88 
89     oslInterlockedCount m_count;
90 };
91 
92 class Impl1: public Interface1, private Base {
93 public:
queryInterface(css::uno::Type const & type)94     virtual css::uno::Any SAL_CALL queryInterface(css::uno::Type const & type)
95     {
96         if (type
97             == getCppuType< css::uno::Reference< css::uno::XInterface > >())
98         {
99             css::uno::Reference< css::uno::XInterface > ref(
100                 static_cast< css::uno::XInterface * >(this));
101             return css::uno::Any(&ref, type);
102         } else if (type == getCppuType< css::uno::Reference< Interface1 > >()) {
103             css::uno::Reference< Interface1 > ref(this);
104             return css::uno::Any(&ref, type);
105         } else {
106             return css::uno::Any();
107         }
108     }
109 
acquire()110     virtual void SAL_CALL acquire() throw () {
111         Base::acquire();
112     }
113 
release()114     virtual void SAL_CALL release() throw () {
115         Base::release();
116     }
117 };
118 
119 class Impl2: public Interface2a, public Interface3, private Base {
120 public:
queryInterface(css::uno::Type const & type)121     virtual css::uno::Any SAL_CALL queryInterface(css::uno::Type const & type)
122     {
123         if (type
124             == getCppuType< css::uno::Reference< css::uno::XInterface > >())
125         {
126             css::uno::Reference< css::uno::XInterface > ref(
127                 static_cast< css::uno::XInterface * >(
128                     static_cast< Interface2a * >(this)));
129             return css::uno::Any(&ref, type);
130         } else if (type == getCppuType< css::uno::Reference< Interface2 > >()) {
131             css::uno::Reference< Interface2 > ref(this);
132             return css::uno::Any(&ref, type);
133         } else if (type == getCppuType< css::uno::Reference< Interface2a > >())
134         {
135             css::uno::Reference< Interface2a > ref(this);
136             return css::uno::Any(&ref, type);
137         } else if (type == getCppuType< css::uno::Reference< Interface3 > >()) {
138             css::uno::Reference< Interface3 > ref(this);
139             return css::uno::Any(&ref, type);
140         } else {
141             return css::uno::Any();
142         }
143     }
144 
acquire()145     virtual void SAL_CALL acquire() throw () {
146         Base::acquire();
147     }
148 
release()149     virtual void SAL_CALL release() throw () {
150         Base::release();
151     }
152 };
153 
154 class Impl2b: public Interface2b, private Base {
155 public:
queryInterface(css::uno::Type const & type)156     virtual css::uno::Any SAL_CALL queryInterface(css::uno::Type const & type)
157     {
158         if (type
159             == getCppuType< css::uno::Reference< css::uno::XInterface > >())
160         {
161             css::uno::Reference< css::uno::XInterface > ref(
162                 static_cast< css::uno::XInterface * >(
163                     static_cast< Interface2a * >(this)));
164             return css::uno::Any(&ref, type);
165         } else if (type == getCppuType< css::uno::Reference< Interface2 > >()) {
166             css::uno::Reference< Interface2 > ref(this);
167             return css::uno::Any(&ref, type);
168         } else if (type == getCppuType< css::uno::Reference< Interface2a > >())
169         {
170             css::uno::Reference< Interface2a > ref(this);
171             return css::uno::Any(&ref, type);
172         } else if (type == getCppuType< css::uno::Reference< Interface2b > >())
173         {
174             css::uno::Reference< Interface2b > ref(this);
175             return css::uno::Any(&ref, type);
176         } else {
177             return css::uno::Any();
178         }
179     }
180 
acquire()181     virtual void SAL_CALL acquire() throw () {
182         Base::acquire();
183     }
184 
release()185     virtual void SAL_CALL release() throw () {
186         Base::release();
187     }
188 };
189 
190 class Test: public ::testing::Test {
191 public:
192 };
193 
TEST_F(Test,testVoid)194 TEST_F(Test, testVoid) {
195     css::uno::Any a;
196     ASSERT_TRUE(a.getValueType() == getVoidCppuType());
197     {
198         bool b = true;
199         ASSERT_TRUE(!(a >>= b) && b) << "bool";
200     }
201     {
202         sal_Bool b = true;
203         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
204     }
205     {
206         sal_Int8 b = 2;
207         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
208     }
209     {
210         sal_uInt8 b = 2;
211         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
212     }
213     {
214         sal_Int16 b = 2;
215         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
216     }
217     {
218         sal_uInt16 b = 2;
219         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
220     }
221     {
222         sal_Int32 b = 2;
223         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
224     }
225     {
226         sal_uInt32 b = 2;
227         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
228     }
229     {
230         sal_Int64 b = 2;
231         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
232     }
233     {
234         sal_uInt64 b = 2;
235         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
236     }
237     {
238         float b = 2;
239         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
240     }
241     {
242         double b = 2;
243         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
244     }
245     {
246         sal_Unicode b = '2';
247         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
248     }
249     {
250         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
251         ASSERT_TRUE(
252             !(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) << "rtl::OUString";
253     }
254     {
255         css::uno::Type b(getCppuType< rtl::OUString >());
256         ASSERT_TRUE(
257             !(a >>= b) && b == getCppuType< rtl::OUString >()) << "css::uno::Type";
258     }
259     {
260         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
261         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
262     }
263     {
264         css::uno::Sequence< rtl::OUString > b(2);
265         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) << "css::uno::Sequence<rtl::OUString>";
266     }
267     {
268         Enum1 b = Enum1_M2;
269         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
270     }
271     {
272         Struct1 b(2);
273         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
274     }
275     {
276         Exception1 b(
277             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
278         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
279     }
280     {
281         css::uno::Reference< Interface1 > i(new Impl1);
282         css::uno::Reference< Interface1 > b(i);
283         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
284     }
285 }
286 
TEST_F(Test,testBoolean)287 TEST_F(Test, testBoolean) {
288     css::uno::Any a(false);
289     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Bool >());
290     {
291         bool b = true;
292         ASSERT_TRUE((a >>= b) && !b) << "bool";
293     }
294     {
295         sal_Bool b = true;
296         ASSERT_TRUE((a >>= b) && !b) << "sal_Bool";
297     }
298     {
299         sal_Int8 b = 2;
300         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
301     }
302     {
303         sal_uInt8 b = 2;
304         if (boost::is_same< sal_uInt8, sal_Bool >::value) {
305             ASSERT_TRUE((a >>= b) && b == 0) << "@sal_uInt8";
306         } else {
307             ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
308         }
309     }
310     {
311         sal_Int16 b = 2;
312         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
313     }
314     {
315         sal_uInt16 b = 2;
316         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
317     }
318     {
319         sal_Int32 b = 2;
320         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
321     }
322     {
323         sal_uInt32 b = 2;
324         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
325     }
326     {
327         sal_Int64 b = 2;
328         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
329     }
330     {
331         sal_uInt64 b = 2;
332         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
333     }
334     {
335         float b = 2;
336         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
337     }
338     {
339         double b = 2;
340         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
341     }
342     {
343         sal_Unicode b = '2';
344         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
345     }
346     {
347         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
348         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
349             "rtl::OUString";
350     }
351     {
352         css::uno::Type b(getCppuType< rtl::OUString >());
353         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
354             "css::uno::Type";
355     }
356     {
357         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
358         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
359     }
360     {
361         css::uno::Sequence< rtl::OUString > b(2);
362         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
363             "css::uno::Sequence<rtl::OUString>";
364     }
365     {
366         Enum1 b = Enum1_M2;
367         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
368     }
369     {
370         Struct1 b(2);
371         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
372     }
373     {
374         Exception1 b(
375             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
376         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
377     }
378     {
379         css::uno::Reference< Interface1 > i(new Impl1);
380         css::uno::Reference< Interface1 > b(i);
381         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
382     }
383 }
384 
TEST_F(Test,testByte)385 TEST_F(Test, testByte) {
386     css::uno::Any a(static_cast< sal_Int8 >(1));
387     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Int8 >());
388     {
389         bool b = true;
390         ASSERT_TRUE(!(a >>= b) && b) << "bool";
391     }
392     {
393         sal_Bool b = true;
394         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
395     }
396     {
397         sal_Int8 b = 2;
398         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int8";
399     }
400     {
401         sal_uInt8 b = 2;
402         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
403     }
404     {
405         sal_Int16 b = 2;
406         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int16";
407     }
408     {
409         sal_uInt16 b = 2;
410         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt16";
411     }
412     {
413         sal_Int32 b = 2;
414         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int32";
415     }
416     {
417         sal_uInt32 b = 2;
418         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt32";
419     }
420     {
421         sal_Int64 b = 2;
422         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
423     }
424     {
425         sal_uInt64 b = 2;
426         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
427     }
428     {
429         float b = 2;
430         ASSERT_TRUE((a >>= b) && b == 1) << "float";
431     }
432     {
433         double b = 2;
434         ASSERT_TRUE((a >>= b) && b == 1) << "double";
435     }
436     {
437         sal_Unicode b = '2';
438         if (boost::is_same< sal_Unicode, sal_uInt16 >::value) {
439             ASSERT_TRUE((a >>= b) && b == 1) << "@sal_Unicode";
440         } else {
441             ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
442         }
443     }
444     {
445         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
446         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
447             "rtl::OUString";
448     }
449     {
450         css::uno::Type b(getCppuType< rtl::OUString >());
451         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
452             "css::uno::Type";
453     }
454     {
455         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
456         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
457     }
458     {
459         css::uno::Sequence< rtl::OUString > b(2);
460         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
461             "css::uno::Sequence<rtl::OUString>";
462     }
463     {
464         Enum1 b = Enum1_M2;
465         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
466     }
467     {
468         Struct1 b(2);
469         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
470     }
471     {
472         Exception1 b(
473             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
474         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
475     }
476     {
477         css::uno::Reference< Interface1 > i(new Impl1);
478         css::uno::Reference< Interface1 > b(i);
479         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
480     }
481 }
482 
TEST_F(Test,testShort)483 TEST_F(Test, testShort) {
484     css::uno::Any a(static_cast< sal_Int16 >(1));
485     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Int16 >());
486     {
487         bool b = true;
488         ASSERT_TRUE(!(a >>= b) && b) << "bool";
489     }
490     {
491         sal_Bool b = true;
492         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
493     }
494     {
495         sal_Int8 b = 2;
496         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
497     }
498     {
499         sal_uInt8 b = 2;
500         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
501     }
502     {
503         sal_Int16 b = 2;
504         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int16";
505     }
506     {
507         sal_uInt16 b = 2;
508         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt16";
509     }
510     {
511         sal_Int32 b = 2;
512         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int32";
513     }
514     {
515         sal_uInt32 b = 2;
516         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt32";
517     }
518     {
519         sal_Int64 b = 2;
520         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
521     }
522     {
523         sal_uInt64 b = 2;
524         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
525     }
526     {
527         float b = 2;
528         ASSERT_TRUE((a >>= b) && b == 1) << "float";
529     }
530     {
531         double b = 2;
532         ASSERT_TRUE((a >>= b) && b == 1) << "double";
533     }
534     {
535         sal_Unicode b = '2';
536         if (boost::is_same< sal_Unicode, sal_uInt16 >::value) {
537             ASSERT_TRUE((a >>= b) && b == 1) << "@sal_Unicode";
538         } else {
539             ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
540         }
541     }
542     {
543         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
544         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
545             "rtl::OUString";
546     }
547     {
548         css::uno::Type b(getCppuType< rtl::OUString >());
549         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
550             "css::uno::Type";
551     }
552     {
553         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
554         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
555     }
556     {
557         css::uno::Sequence< rtl::OUString > b(2);
558         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
559             "css::uno::Sequence<rtl::OUString>";
560     }
561     {
562         Enum1 b = Enum1_M2;
563         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
564     }
565     {
566         Struct1 b(2);
567         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
568     }
569     {
570         Exception1 b(
571             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
572         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
573     }
574     {
575         css::uno::Reference< Interface1 > i(new Impl1);
576         css::uno::Reference< Interface1 > b(i);
577         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
578     }
579 }
580 
TEST_F(Test,testUnsignedShort)581 TEST_F(Test, testUnsignedShort) {
582     sal_uInt16 n = 1;
583     css::uno::Any a(&n, getCppuType(static_cast< sal_uInt16 const * >(0)));
584     ASSERT_TRUE(
585         a.getValueType() == getCppuType(static_cast< sal_uInt16 const * >(0)));
586     {
587         bool b = true;
588         ASSERT_TRUE(!(a >>= b) && b) << "bool";
589     }
590     {
591         sal_Bool b = true;
592         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
593     }
594     {
595         sal_Int8 b = 2;
596         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
597     }
598     {
599         sal_uInt8 b = 2;
600         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
601     }
602     {
603         sal_Int16 b = 2;
604         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int16";
605     }
606     {
607         sal_uInt16 b = 2;
608         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt16";
609     }
610     {
611         sal_Int32 b = 2;
612         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int32";
613     }
614     {
615         sal_uInt32 b = 2;
616         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt32";
617     }
618     {
619         sal_Int64 b = 2;
620         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
621     }
622     {
623         sal_uInt64 b = 2;
624         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
625     }
626     {
627         float b = 2;
628         ASSERT_TRUE((a >>= b) && b == 1) << "float";
629     }
630     {
631         double b = 2;
632         ASSERT_TRUE((a >>= b) && b == 1) << "double";
633     }
634     {
635         sal_Unicode b = '2';
636         if (boost::is_same< sal_Unicode, sal_uInt16 >::value) {
637             ASSERT_TRUE((a >>= b) && b == 1) << "@sal_Unicode";
638         } else {
639             ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
640         }
641     }
642     {
643         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
644         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
645             "rtl::OUString";
646     }
647     {
648         css::uno::Type b(getCppuType< rtl::OUString >());
649         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
650             "css::uno::Type";
651     }
652     {
653         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
654         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
655     }
656     {
657         css::uno::Sequence< rtl::OUString > b(2);
658         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
659             "css::uno::Sequence<rtl::OUString>";
660     }
661     {
662         Enum1 b = Enum1_M2;
663         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
664     }
665     {
666         Struct1 b(2);
667         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
668     }
669     {
670         Exception1 b(
671             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
672         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
673     }
674     {
675         css::uno::Reference< Interface1 > i(new Impl1);
676         css::uno::Reference< Interface1 > b(i);
677         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
678     }
679 }
680 
TEST_F(Test,testLong)681 TEST_F(Test, testLong) {
682     css::uno::Any a(static_cast< sal_Int32 >(1));
683     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Int32 >());
684     {
685         bool b = true;
686         ASSERT_TRUE(!(a >>= b) && b) << "bool";
687     }
688     {
689         sal_Bool b = true;
690         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
691     }
692     {
693         sal_Int8 b = 2;
694         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
695     }
696     {
697         sal_uInt8 b = 2;
698         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
699     }
700     {
701         sal_Int16 b = 2;
702         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
703     }
704     {
705         sal_uInt16 b = 2;
706         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
707     }
708     {
709         sal_Int32 b = 2;
710         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int32";
711     }
712     {
713         sal_uInt32 b = 2;
714         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt32";
715     }
716     {
717         sal_Int64 b = 2;
718         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
719     }
720     {
721         sal_uInt64 b = 2;
722         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
723     }
724     {
725         float b = 2;
726         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
727     }
728     {
729         double b = 2;
730         ASSERT_TRUE((a >>= b) && b == 1) << "double";
731     }
732     {
733         sal_Unicode b = '2';
734         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
735     }
736     {
737         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
738         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
739             "rtl::OUString";
740     }
741     {
742         css::uno::Type b(getCppuType< rtl::OUString >());
743         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
744             "css::uno::Type";
745     }
746     {
747         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
748         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
749     }
750     {
751         css::uno::Sequence< rtl::OUString > b(2);
752         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
753             "css::uno::Sequence<rtl::OUString>";
754     }
755     {
756         Enum1 b = Enum1_M2;
757         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
758     }
759     {
760         Struct1 b(2);
761         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
762     }
763     {
764         Exception1 b(
765             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
766         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
767     }
768     {
769         css::uno::Reference< Interface1 > i(new Impl1);
770         css::uno::Reference< Interface1 > b(i);
771         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
772     }
773 }
774 
TEST_F(Test,testUnsignedLong)775 TEST_F(Test, testUnsignedLong) {
776     css::uno::Any a(static_cast< sal_uInt32 >(1));
777     ASSERT_TRUE(a.getValueType() == getCppuType< sal_uInt32 >());
778     {
779         bool b = true;
780         ASSERT_TRUE(!(a >>= b) && b) << "bool";
781     }
782     {
783         sal_Bool b = true;
784         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
785     }
786     {
787         sal_Int8 b = 2;
788         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
789     }
790     {
791         sal_uInt8 b = 2;
792         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
793     }
794     {
795         sal_Int16 b = 2;
796         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
797     }
798     {
799         sal_uInt16 b = 2;
800         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
801     }
802     {
803         sal_Int32 b = 2;
804         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int32";
805     }
806     {
807         sal_uInt32 b = 2;
808         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt32";
809     }
810     {
811         sal_Int64 b = 2;
812         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
813     }
814     {
815         sal_uInt64 b = 2;
816         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
817     }
818     {
819         float b = 2;
820         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
821     }
822     {
823         double b = 2;
824         ASSERT_TRUE((a >>= b) && b == 1) << "double";
825     }
826     {
827         sal_Unicode b = '2';
828         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
829     }
830     {
831         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
832         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
833             "rtl::OUString";
834     }
835     {
836         css::uno::Type b(getCppuType< rtl::OUString >());
837         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
838             "css::uno::Type";
839     }
840     {
841         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
842         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
843     }
844     {
845         css::uno::Sequence< rtl::OUString > b(2);
846         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
847             "css::uno::Sequence<rtl::OUString>";
848     }
849     {
850         Enum1 b = Enum1_M2;
851         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
852     }
853     {
854         Struct1 b(2);
855         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
856     }
857     {
858         Exception1 b(
859             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
860         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
861     }
862     {
863         css::uno::Reference< Interface1 > i(new Impl1);
864         css::uno::Reference< Interface1 > b(i);
865         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
866     }
867 }
868 
TEST_F(Test,testHyper)869 TEST_F(Test, testHyper) {
870     css::uno::Any a(static_cast< sal_Int64 >(1));
871     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Int64 >());
872     {
873         bool b = true;
874         ASSERT_TRUE(!(a >>= b) && b) << "bool";
875     }
876     {
877         sal_Bool b = true;
878         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
879     }
880     {
881         sal_Int8 b = 2;
882         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
883     }
884     {
885         sal_uInt8 b = 2;
886         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
887     }
888     {
889         sal_Int16 b = 2;
890         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
891     }
892     {
893         sal_uInt16 b = 2;
894         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
895     }
896     {
897         sal_Int32 b = 2;
898         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
899     }
900     {
901         sal_uInt32 b = 2;
902         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
903     }
904     {
905         sal_Int64 b = 2;
906         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
907     }
908     {
909         sal_uInt64 b = 2;
910         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
911     }
912     {
913         float b = 2;
914         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
915     }
916     {
917         double b = 2;
918         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
919     }
920     {
921         sal_Unicode b = '2';
922         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
923     }
924     {
925         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
926         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
927             "rtl::OUString";
928     }
929     {
930         css::uno::Type b(getCppuType< rtl::OUString >());
931         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
932             "css::uno::Type";
933     }
934     {
935         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
936         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
937     }
938     {
939         css::uno::Sequence< rtl::OUString > b(2);
940         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
941             "css::uno::Sequence<rtl::OUString>";
942     }
943     {
944         Enum1 b = Enum1_M2;
945         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
946     }
947     {
948         Struct1 b(2);
949         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
950     }
951     {
952         Exception1 b(
953             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
954         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
955     }
956     {
957         css::uno::Reference< Interface1 > i(new Impl1);
958         css::uno::Reference< Interface1 > b(i);
959         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
960     }
961 }
962 
TEST_F(Test,testUnsignedHyper)963 TEST_F(Test, testUnsignedHyper) {
964     css::uno::Any a(static_cast< sal_uInt64 >(1));
965     ASSERT_TRUE(a.getValueType() == getCppuType< sal_uInt64 >());
966     {
967         bool b = true;
968         ASSERT_TRUE(!(a >>= b) && b) << "bool";
969     }
970     {
971         sal_Bool b = true;
972         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
973     }
974     {
975         sal_Int8 b = 2;
976         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
977     }
978     {
979         sal_uInt8 b = 2;
980         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
981     }
982     {
983         sal_Int16 b = 2;
984         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
985     }
986     {
987         sal_uInt16 b = 2;
988         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
989     }
990     {
991         sal_Int32 b = 2;
992         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
993     }
994     {
995         sal_uInt32 b = 2;
996         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
997     }
998     {
999         sal_Int64 b = 2;
1000         ASSERT_TRUE((a >>= b) && b == 1) << "sal_Int64";
1001     }
1002     {
1003         sal_uInt64 b = 2;
1004         ASSERT_TRUE((a >>= b) && b == 1) << "sal_uInt64";
1005     }
1006     {
1007         float b = 2;
1008         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1009     }
1010     {
1011         double b = 2;
1012         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1013     }
1014     {
1015         sal_Unicode b = '2';
1016         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1017     }
1018     {
1019         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1020         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1021             "rtl::OUString";
1022     }
1023     {
1024         css::uno::Type b(getCppuType< rtl::OUString >());
1025         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1026             "css::uno::Type";
1027     }
1028     {
1029         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1030         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1031     }
1032     {
1033         css::uno::Sequence< rtl::OUString > b(2);
1034         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1035             "css::uno::Sequence<rtl::OUString>";
1036     }
1037     {
1038         Enum1 b = Enum1_M2;
1039         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1040     }
1041     {
1042         Struct1 b(2);
1043         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1044     }
1045     {
1046         Exception1 b(
1047             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1048         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1049     }
1050     {
1051         css::uno::Reference< Interface1 > i(new Impl1);
1052         css::uno::Reference< Interface1 > b(i);
1053         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1054     }
1055 }
1056 
TEST_F(Test,testFloat)1057 TEST_F(Test, testFloat) {
1058     css::uno::Any a(1.f);
1059     ASSERT_TRUE(a.getValueType() == getCppuType< float >());
1060     {
1061         bool b = true;
1062         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1063     }
1064     {
1065         sal_Bool b = true;
1066         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1067     }
1068     {
1069         sal_Int8 b = 2;
1070         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1071     }
1072     {
1073         sal_uInt8 b = 2;
1074         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1075     }
1076     {
1077         sal_Int16 b = 2;
1078         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1079     }
1080     {
1081         sal_uInt16 b = 2;
1082         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1083     }
1084     {
1085         sal_Int32 b = 2;
1086         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1087     }
1088     {
1089         sal_uInt32 b = 2;
1090         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1091     }
1092     {
1093         sal_Int64 b = 2;
1094         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1095     }
1096     {
1097         sal_uInt64 b = 2;
1098         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1099     }
1100     {
1101         float b = 2;
1102         ASSERT_TRUE((a >>= b) && b == 1) << "float";
1103     }
1104     {
1105         double b = 2;
1106         ASSERT_TRUE((a >>= b) && b == 1) << "double";
1107     }
1108     {
1109         sal_Unicode b = '2';
1110         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1111     }
1112     {
1113         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1114         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1115             "rtl::OUString";
1116     }
1117     {
1118         css::uno::Type b(getCppuType< rtl::OUString >());
1119         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1120             "css::uno::Type";
1121     }
1122     {
1123         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1124         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1125     }
1126     {
1127         css::uno::Sequence< rtl::OUString > b(2);
1128         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1129             "css::uno::Sequence<rtl::OUString>";
1130     }
1131     {
1132         Enum1 b = Enum1_M2;
1133         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1134     }
1135     {
1136         Struct1 b(2);
1137         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1138     }
1139     {
1140         Exception1 b(
1141             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1142         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1143     }
1144     {
1145         css::uno::Reference< Interface1 > i(new Impl1);
1146         css::uno::Reference< Interface1 > b(i);
1147         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1148     }
1149 }
1150 
TEST_F(Test,testDouble)1151 TEST_F(Test, testDouble) {
1152     css::uno::Any a(1.);
1153     ASSERT_TRUE(a.getValueType() == getCppuType< double >());
1154     {
1155         bool b = true;
1156         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1157     }
1158     {
1159         sal_Bool b = true;
1160         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1161     }
1162     {
1163         sal_Int8 b = 2;
1164         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1165     }
1166     {
1167         sal_uInt8 b = 2;
1168         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1169     }
1170     {
1171         sal_Int16 b = 2;
1172         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1173     }
1174     {
1175         sal_uInt16 b = 2;
1176         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1177     }
1178     {
1179         sal_Int32 b = 2;
1180         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1181     }
1182     {
1183         sal_uInt32 b = 2;
1184         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1185     }
1186     {
1187         sal_Int64 b = 2;
1188         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1189     }
1190     {
1191         sal_uInt64 b = 2;
1192         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1193     }
1194     {
1195         float b = 2;
1196         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1197     }
1198     {
1199         double b = 2;
1200         ASSERT_TRUE((a >>= b) && b == 1) << "double";
1201     }
1202     {
1203         sal_Unicode b = '2';
1204         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1205     }
1206     {
1207         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1208         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1209             "rtl::OUString";
1210     }
1211     {
1212         css::uno::Type b(getCppuType< rtl::OUString >());
1213         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1214             "css::uno::Type";
1215     }
1216     {
1217         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1218         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1219     }
1220     {
1221         css::uno::Sequence< rtl::OUString > b(2);
1222         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1223             "css::uno::Sequence<rtl::OUString>";
1224     }
1225     {
1226         Enum1 b = Enum1_M2;
1227         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1228     }
1229     {
1230         Struct1 b(2);
1231         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1232     }
1233     {
1234         Exception1 b(
1235             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1236         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1237     }
1238     {
1239         css::uno::Reference< Interface1 > i(new Impl1);
1240         css::uno::Reference< Interface1 > b(i);
1241         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1242     }
1243 }
1244 
TEST_F(Test,testChar)1245 TEST_F(Test, testChar) {
1246     sal_Unicode c = '1';
1247     css::uno::Any a(&c, getCppuType< sal_Unicode >());
1248     ASSERT_TRUE(a.getValueType() == getCppuType< sal_Unicode >());
1249     {
1250         bool b = true;
1251         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1252     }
1253     {
1254         sal_Bool b = true;
1255         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1256     }
1257     {
1258         sal_Int8 b = 2;
1259         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1260     }
1261     {
1262         sal_uInt8 b = 2;
1263         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1264     }
1265     {
1266         sal_Int16 b = 2;
1267         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1268     }
1269     {
1270         sal_uInt16 b = 2;
1271         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1272     }
1273     {
1274         sal_Int32 b = 2;
1275         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1276     }
1277     {
1278         sal_uInt32 b = 2;
1279         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1280     }
1281     {
1282         sal_Int64 b = 2;
1283         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1284     }
1285     {
1286         sal_uInt64 b = 2;
1287         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1288     }
1289     {
1290         float b = 2;
1291         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1292     }
1293     {
1294         double b = 2;
1295         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1296     }
1297     {
1298         sal_Unicode b = '2';
1299         if (boost::is_same< sal_Unicode, sal_uInt16 >::value) {
1300             ASSERT_TRUE(!(a >>= b) && b == '2') << "@sal_Unicode";
1301         } else {
1302             ASSERT_TRUE((a >>= b) && b == '1') << "sal_Unicode";
1303         }
1304     }
1305     {
1306         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1307         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1308             "rtl::OUString";
1309     }
1310     {
1311         css::uno::Type b(getCppuType< rtl::OUString >());
1312         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1313             "css::uno::Type";
1314     }
1315     {
1316         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1317         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1318     }
1319     {
1320         css::uno::Sequence< rtl::OUString > b(2);
1321         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1322             "css::uno::Sequence<rtl::OUString>";
1323     }
1324     {
1325         Enum1 b = Enum1_M2;
1326         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1327     }
1328     {
1329         Struct1 b(2);
1330         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1331     }
1332     {
1333         Exception1 b(
1334             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1335         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1336     }
1337     {
1338         css::uno::Reference< Interface1 > i(new Impl1);
1339         css::uno::Reference< Interface1 > b(i);
1340         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1341     }
1342 }
1343 
TEST_F(Test,testString)1344 TEST_F(Test, testString) {
1345     css::uno::Any a(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("1")));
1346     ASSERT_TRUE(a.getValueType() == getCppuType< rtl::OUString >());
1347     {
1348         bool b = true;
1349         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1350     }
1351     {
1352         sal_Bool b = true;
1353         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1354     }
1355     {
1356         sal_Int8 b = 2;
1357         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1358     }
1359     {
1360         sal_uInt8 b = 2;
1361         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1362     }
1363     {
1364         sal_Int16 b = 2;
1365         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1366     }
1367     {
1368         sal_uInt16 b = 2;
1369         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1370     }
1371     {
1372         sal_Int32 b = 2;
1373         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1374     }
1375     {
1376         sal_uInt32 b = 2;
1377         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1378     }
1379     {
1380         sal_Int64 b = 2;
1381         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1382     }
1383     {
1384         sal_uInt64 b = 2;
1385         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1386     }
1387     {
1388         float b = 2;
1389         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1390     }
1391     {
1392         double b = 2;
1393         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1394     }
1395     {
1396         sal_Unicode b = '2';
1397         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1398     }
1399     {
1400         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1401         ASSERT_TRUE((a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("1"))) <<
1402             "rtl::OUString";
1403     }
1404     {
1405         css::uno::Type b(getCppuType< rtl::OUString >());
1406         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1407             "css::uno::Type";
1408     }
1409     {
1410         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1411         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1412     }
1413     {
1414         css::uno::Sequence< rtl::OUString > b(2);
1415         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1416             "css::uno::Sequence<rtl::OUString>";
1417     }
1418     {
1419         Enum1 b = Enum1_M2;
1420         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1421     }
1422     {
1423         Struct1 b(2);
1424         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1425     }
1426     {
1427         Exception1 b(
1428             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1429         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1430     }
1431     {
1432         css::uno::Reference< Interface1 > i(new Impl1);
1433         css::uno::Reference< Interface1 > b(i);
1434         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1435     }
1436 }
1437 
TEST_F(Test,testType)1438 TEST_F(Test, testType) {
1439     css::uno::Any a(getCppuType< sal_Int32 >());
1440     ASSERT_TRUE(a.getValueType() == getCppuType< css::uno::Type >());
1441     {
1442         bool b = true;
1443         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1444     }
1445     {
1446         sal_Bool b = true;
1447         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1448     }
1449     {
1450         sal_Int8 b = 2;
1451         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1452     }
1453     {
1454         sal_uInt8 b = 2;
1455         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1456     }
1457     {
1458         sal_Int16 b = 2;
1459         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1460     }
1461     {
1462         sal_uInt16 b = 2;
1463         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1464     }
1465     {
1466         sal_Int32 b = 2;
1467         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1468     }
1469     {
1470         sal_uInt32 b = 2;
1471         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1472     }
1473     {
1474         sal_Int64 b = 2;
1475         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1476     }
1477     {
1478         sal_uInt64 b = 2;
1479         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1480     }
1481     {
1482         float b = 2;
1483         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1484     }
1485     {
1486         double b = 2;
1487         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1488     }
1489     {
1490         sal_Unicode b = '2';
1491         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1492     }
1493     {
1494         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1495         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1496             "rtl::OUString";
1497     }
1498     {
1499         css::uno::Type b(getCppuType< rtl::OUString >());
1500         ASSERT_TRUE((a >>= b) && b == getCppuType< sal_Int32 >()) <<
1501             "css::uno::Type";
1502     }
1503     {
1504         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1505         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1506     }
1507     {
1508         css::uno::Sequence< rtl::OUString > b(2);
1509         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1510             "css::uno::Sequence<rtl::OUString>";
1511     }
1512     {
1513         Enum1 b = Enum1_M2;
1514         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1515     }
1516     {
1517         Struct1 b(2);
1518         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1519     }
1520     {
1521         Exception1 b(
1522             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1523         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1524     }
1525     {
1526         css::uno::Reference< Interface1 > i(new Impl1);
1527         css::uno::Reference< Interface1 > b(i);
1528         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1529     }
1530 }
1531 
TEST_F(Test,testSequence)1532 TEST_F(Test, testSequence) {
1533     sal_Int32 n = 1;
1534     css::uno::Any a(css::uno::Sequence< sal_Int32 >(&n, 1));
1535     ASSERT_TRUE(
1536         a.getValueType() == getCppuType< css::uno::Sequence< sal_Int32 > >());
1537     {
1538         bool b = true;
1539         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1540     }
1541     {
1542         sal_Bool b = true;
1543         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1544     }
1545     {
1546         sal_Int8 b = 2;
1547         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1548     }
1549     {
1550         sal_uInt8 b = 2;
1551         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1552     }
1553     {
1554         sal_Int16 b = 2;
1555         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1556     }
1557     {
1558         sal_uInt16 b = 2;
1559         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1560     }
1561     {
1562         sal_Int32 b = 2;
1563         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1564     }
1565     {
1566         sal_uInt32 b = 2;
1567         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1568     }
1569     {
1570         sal_Int64 b = 2;
1571         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1572     }
1573     {
1574         sal_uInt64 b = 2;
1575         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1576     }
1577     {
1578         float b = 2;
1579         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1580     }
1581     {
1582         double b = 2;
1583         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1584     }
1585     {
1586         sal_Unicode b = '2';
1587         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1588     }
1589     {
1590         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1591         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1592             "rtl::OUString";
1593     }
1594     {
1595         css::uno::Type b(getCppuType< rtl::OUString >());
1596         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1597             "css::uno::Type";
1598     }
1599     {
1600         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1601         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1602     }
1603     {
1604         css::uno::Sequence< rtl::OUString > b(2);
1605         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1606             "css::uno::Sequence<rtl::OUString>";
1607     }
1608     {
1609         css::uno::Sequence< sal_Int32 > b(2);
1610         ASSERT_TRUE((a >>= b) && b.getLength() == 1 && b[0] == 1) <<
1611             "css::uno::Sequence<sal_Int32>";
1612     }
1613     {
1614         Enum1 b = Enum1_M2;
1615         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1616     }
1617     {
1618         Struct1 b(2);
1619         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1620     }
1621     {
1622         Exception1 b(
1623             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1624         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1625     }
1626     {
1627         css::uno::Reference< Interface1 > i(new Impl1);
1628         css::uno::Reference< Interface1 > b(i);
1629         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1630     }
1631 }
1632 
TEST_F(Test,testEnum)1633 TEST_F(Test, testEnum) {
1634     css::uno::Any a(Enum2_M1);
1635     ASSERT_TRUE(a.getValueType() == getCppuType< Enum2 >());
1636     {
1637         bool b = true;
1638         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1639     }
1640     {
1641         sal_Bool b = true;
1642         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1643     }
1644     {
1645         sal_Int8 b = 2;
1646         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1647     }
1648     {
1649         sal_uInt8 b = 2;
1650         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1651     }
1652     {
1653         sal_Int16 b = 2;
1654         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1655     }
1656     {
1657         sal_uInt16 b = 2;
1658         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1659     }
1660     {
1661         sal_Int32 b = 2;
1662         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1663     }
1664     {
1665         sal_uInt32 b = 2;
1666         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1667     }
1668     {
1669         sal_Int64 b = 2;
1670         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1671     }
1672     {
1673         sal_uInt64 b = 2;
1674         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1675     }
1676     {
1677         float b = 2;
1678         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1679     }
1680     {
1681         double b = 2;
1682         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1683     }
1684     {
1685         sal_Unicode b = '2';
1686         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1687     }
1688     {
1689         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1690         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1691             "rtl::OUString";
1692     }
1693     {
1694         css::uno::Type b(getCppuType< rtl::OUString >());
1695         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1696             "css::uno::Type";
1697     }
1698     {
1699         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1700         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1701     }
1702     {
1703         css::uno::Sequence< rtl::OUString > b(2);
1704         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1705             "css::uno::Sequence<rtl::OUString>";
1706     }
1707     {
1708         Enum1 b = Enum1_M2;
1709         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1710     }
1711     {
1712         Enum2 b = Enum2_M2;
1713         ASSERT_TRUE((a >>= b) && b == Enum2_M1) << "Enum2";
1714     }
1715     {
1716         Struct1 b(2);
1717         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1718     }
1719     {
1720         Exception1 b(
1721             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1722         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1723     }
1724     {
1725         css::uno::Reference< Interface1 > i(new Impl1);
1726         css::uno::Reference< Interface1 > b(i);
1727         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1728     }
1729 }
1730 
TEST_F(Test,testStruct)1731 TEST_F(Test, testStruct) {
1732     css::uno::Any a(Struct2a(1, 3));
1733     ASSERT_TRUE(a.getValueType() == getCppuType< Struct2a >());
1734     {
1735         bool b = true;
1736         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1737     }
1738     {
1739         sal_Bool b = true;
1740         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1741     }
1742     {
1743         sal_Int8 b = 2;
1744         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1745     }
1746     {
1747         sal_uInt8 b = 2;
1748         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1749     }
1750     {
1751         sal_Int16 b = 2;
1752         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1753     }
1754     {
1755         sal_uInt16 b = 2;
1756         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1757     }
1758     {
1759         sal_Int32 b = 2;
1760         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1761     }
1762     {
1763         sal_uInt32 b = 2;
1764         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1765     }
1766     {
1767         sal_Int64 b = 2;
1768         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1769     }
1770     {
1771         sal_uInt64 b = 2;
1772         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1773     }
1774     {
1775         float b = 2;
1776         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1777     }
1778     {
1779         double b = 2;
1780         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1781     }
1782     {
1783         sal_Unicode b = '2';
1784         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1785     }
1786     {
1787         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1788         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1789             "rtl::OUString";
1790     }
1791     {
1792         css::uno::Type b(getCppuType< rtl::OUString >());
1793         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1794             "css::uno::Type";
1795     }
1796     {
1797         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1798         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1799     }
1800     {
1801         css::uno::Sequence< rtl::OUString > b(2);
1802         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1803             "css::uno::Sequence<rtl::OUString>";
1804     }
1805     {
1806         Enum1 b = Enum1_M2;
1807         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1808     }
1809     {
1810         Struct1 b(2);
1811         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1812     }
1813     {
1814         Struct2 b(2);
1815         ASSERT_TRUE((a >>= b) && b.member == 1) << "Struct2";
1816     }
1817     {
1818         Struct2a b(2, 2);
1819         ASSERT_TRUE((a >>= b) && b.member == 1 && b.member2 == 3) <<
1820             "Struct2a";
1821     }
1822     {
1823         Struct2b b(2, 2, 2);
1824         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct2b";
1825     }
1826     {
1827         Exception1 b(
1828             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1829         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1830     }
1831     {
1832         css::uno::Reference< Interface1 > i(new Impl1);
1833         css::uno::Reference< Interface1 > b(i);
1834         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1835     }
1836 }
1837 
TEST_F(Test,testPoly)1838 TEST_F(Test, testPoly) {
1839     css::uno::Any a;
1840     a <<= Poly< css::uno::Sequence< ::sal_Unicode > >();
1841     ASSERT_TRUE(a.getValueType().getTypeName().equalsAsciiL(
1842             RTL_CONSTASCII_STRINGPARAM("Poly<[]char>"))) <<
1843         "type name";
1844     ASSERT_TRUE(a == css::uno::Any(Poly< css::uno::Sequence< ::sal_Unicode > >())) <<
1845         "constructor";
1846 }
1847 
TEST_F(Test,testException)1848 TEST_F(Test, testException) {
1849     css::uno::Any a(
1850         Exception2a(
1851             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 1,
1852             3));
1853     ASSERT_TRUE(a.getValueType() == getCppuType< Exception2a >());
1854     {
1855         bool b = true;
1856         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1857     }
1858     {
1859         sal_Bool b = true;
1860         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1861     }
1862     {
1863         sal_Int8 b = 2;
1864         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1865     }
1866     {
1867         sal_uInt8 b = 2;
1868         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1869     }
1870     {
1871         sal_Int16 b = 2;
1872         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1873     }
1874     {
1875         sal_uInt16 b = 2;
1876         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1877     }
1878     {
1879         sal_Int32 b = 2;
1880         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1881     }
1882     {
1883         sal_uInt32 b = 2;
1884         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
1885     }
1886     {
1887         sal_Int64 b = 2;
1888         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
1889     }
1890     {
1891         sal_uInt64 b = 2;
1892         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
1893     }
1894     {
1895         float b = 2;
1896         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
1897     }
1898     {
1899         double b = 2;
1900         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
1901     }
1902     {
1903         sal_Unicode b = '2';
1904         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
1905     }
1906     {
1907         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
1908         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
1909             "rtl::OUString";
1910     }
1911     {
1912         css::uno::Type b(getCppuType< rtl::OUString >());
1913         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
1914             "css::uno::Type";
1915     }
1916     {
1917         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
1918         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
1919     }
1920     {
1921         css::uno::Sequence< rtl::OUString > b(2);
1922         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
1923             "css::uno::Sequence<rtl::OUString>";
1924     }
1925     {
1926         Enum1 b = Enum1_M2;
1927         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
1928     }
1929     {
1930         Struct1 b(2);
1931         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
1932     }
1933     {
1934         Exception1 b(
1935             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1936         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
1937     }
1938     {
1939         Exception2 b(
1940             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
1941         ASSERT_TRUE((a >>= b) && b.member == 1) << "Exception2";
1942     }
1943     {
1944         Exception2a b(
1945             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2,
1946             2);
1947         ASSERT_TRUE((a >>= b) && b.member == 1 && b.member2 == 3) <<
1948             "Exception2a";
1949     }
1950     {
1951         Exception2b b(
1952             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2,
1953             2);
1954         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception2b";
1955     }
1956     {
1957         css::uno::Reference< Interface1 > i(new Impl1);
1958         css::uno::Reference< Interface1 > b(i);
1959         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
1960     }
1961 }
1962 
TEST_F(Test,testInterface)1963 TEST_F(Test, testInterface) {
1964     css::uno::Reference< Interface2a > i2(new Impl2);
1965     css::uno::Any a(i2);
1966     ASSERT_TRUE(
1967         a.getValueType()
1968         == getCppuType< css::uno::Reference< Interface2a > >());
1969     {
1970         bool b = true;
1971         ASSERT_TRUE(!(a >>= b) && b) << "bool";
1972     }
1973     {
1974         sal_Bool b = true;
1975         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
1976     }
1977     {
1978         sal_Int8 b = 2;
1979         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
1980     }
1981     {
1982         sal_uInt8 b = 2;
1983         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
1984     }
1985     {
1986         sal_Int16 b = 2;
1987         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
1988     }
1989     {
1990         sal_uInt16 b = 2;
1991         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
1992     }
1993     {
1994         sal_Int32 b = 2;
1995         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
1996     }
1997     {
1998         sal_uInt32 b = 2;
1999         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
2000     }
2001     {
2002         sal_Int64 b = 2;
2003         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
2004     }
2005     {
2006         sal_uInt64 b = 2;
2007         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
2008     }
2009     {
2010         float b = 2;
2011         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
2012     }
2013     {
2014         double b = 2;
2015         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
2016     }
2017     {
2018         sal_Unicode b = '2';
2019         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
2020     }
2021     {
2022         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
2023         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
2024             "rtl::OUString";
2025     }
2026     {
2027         css::uno::Type b(getCppuType< rtl::OUString >());
2028         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
2029             "css::uno::Type";
2030     }
2031     {
2032         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
2033         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
2034     }
2035     {
2036         css::uno::Sequence< rtl::OUString > b(2);
2037         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
2038             "css::uno::Sequence<rtl::OUString>";
2039     }
2040     {
2041         Enum1 b = Enum1_M2;
2042         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
2043     }
2044     {
2045         Struct1 b(2);
2046         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
2047     }
2048     {
2049         Exception1 b(
2050             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
2051         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
2052     }
2053     {
2054         css::uno::Reference< Interface1 > i(new Impl1);
2055         css::uno::Reference< Interface1 > b(i);
2056         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface1";
2057     }
2058     {
2059         css::uno::Reference< Interface2 > b(new Impl2);
2060         ASSERT_TRUE((a >>= b) && b == i2) << "Interface2";
2061     }
2062     {
2063         css::uno::Reference< Interface2a > b(new Impl2);
2064         ASSERT_TRUE((a >>= b) && b == i2) << "Interface2a";
2065     }
2066     {
2067         css::uno::Reference< Interface2b > i(new Impl2b);
2068         css::uno::Reference< Interface2b > b(i);
2069         ASSERT_TRUE(!(a >>= b) && b == i) << "Interface2b";
2070     }
2071     {
2072         css::uno::Reference< Interface3 > b(new Impl2);
2073         ASSERT_TRUE((a >>= b) && b == i2) << "Interface3";
2074     }
2075 }
2076 
TEST_F(Test,testNull)2077 TEST_F(Test, testNull) {
2078     css::uno::Any a = css::uno::Any(css::uno::Reference< Interface2a >());
2079     ASSERT_TRUE(
2080         a.getValueType()
2081         == getCppuType< css::uno::Reference< Interface2a > >());
2082     {
2083         bool b = true;
2084         ASSERT_TRUE(!(a >>= b) && b) << "bool";
2085     }
2086     {
2087         sal_Bool b = true;
2088         ASSERT_TRUE(!(a >>= b) && b) << "sal_Bool";
2089     }
2090     {
2091         sal_Int8 b = 2;
2092         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int8";
2093     }
2094     {
2095         sal_uInt8 b = 2;
2096         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt8";
2097     }
2098     {
2099         sal_Int16 b = 2;
2100         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int16";
2101     }
2102     {
2103         sal_uInt16 b = 2;
2104         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt16";
2105     }
2106     {
2107         sal_Int32 b = 2;
2108         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int32";
2109     }
2110     {
2111         sal_uInt32 b = 2;
2112         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt32";
2113     }
2114     {
2115         sal_Int64 b = 2;
2116         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_Int64";
2117     }
2118     {
2119         sal_uInt64 b = 2;
2120         ASSERT_TRUE(!(a >>= b) && b == 2) << "sal_uInt64";
2121     }
2122     {
2123         float b = 2;
2124         ASSERT_TRUE(!(a >>= b) && b == 2) << "float";
2125     }
2126     {
2127         double b = 2;
2128         ASSERT_TRUE(!(a >>= b) && b == 2) << "double";
2129     }
2130     {
2131         sal_Unicode b = '2';
2132         ASSERT_TRUE(!(a >>= b) && b == '2') << "sal_Unicode";
2133     }
2134     {
2135         rtl::OUString b(RTL_CONSTASCII_USTRINGPARAM("2"));
2136         ASSERT_TRUE(!(a >>= b) && b.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("2"))) <<
2137             "rtl::OUString";
2138     }
2139     {
2140         css::uno::Type b(getCppuType< rtl::OUString >());
2141         ASSERT_TRUE(!(a >>= b) && b == getCppuType< rtl::OUString >()) <<
2142             "css::uno::Type";
2143     }
2144     {
2145         css::uno::Any b(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("2")));
2146         ASSERT_TRUE((a >>= b) && b == a) << "css::uno::Any";
2147     }
2148     {
2149         css::uno::Sequence< rtl::OUString > b(2);
2150         ASSERT_TRUE(!(a >>= b) && b.getLength() == 2) <<
2151             "css::uno::Sequence<rtl::OUString>";
2152     }
2153     {
2154         Enum1 b = Enum1_M2;
2155         ASSERT_TRUE(!(a >>= b) && b == Enum1_M2) << "Enum1";
2156     }
2157     {
2158         Struct1 b(2);
2159         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Struct1";
2160     }
2161     {
2162         Exception1 b(
2163             rtl::OUString(), css::uno::Reference< css::uno::XInterface >(), 2);
2164         ASSERT_TRUE(!(a >>= b) && b.member == 2) << "Exception1";
2165     }
2166     {
2167         css::uno::Reference< Interface1 > b(new Impl1);
2168         ASSERT_TRUE((a >>= b) && !b.is()) <<
2169             "Interface1";
2170     }
2171     {
2172         css::uno::Reference< Interface2 > b(new Impl2);
2173         ASSERT_TRUE((a >>= b) && !b.is()) <<
2174             "Interface2";
2175     }
2176     {
2177         css::uno::Reference< Interface2a > b(new Impl2);
2178         ASSERT_TRUE((a >>= b) && !b.is()) << "Interface2a";
2179     }
2180     {
2181         css::uno::Reference< Interface2b > b(new Impl2b);
2182         ASSERT_TRUE((a >>= b) && !b.is()) <<
2183             "Interface2b";
2184     }
2185     {
2186         css::uno::Reference< Interface3 > b(new Impl2);
2187         ASSERT_TRUE((a >>= b) && !b.is()) <<
2188             "Interface3";
2189     }
2190 }
2191 
2192 }
2193