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: 68 Base(): m_count(0) {} 69 70 void acquire() { 71 if (osl_incrementInterlockedCount(&m_count) == SAL_MAX_INT32) { 72 abort(); 73 } 74 } 75 76 void release() { 77 if (osl_decrementInterlockedCount(&m_count) == 0) { 78 delete this; 79 } 80 } 81 82 protected: 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: 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 110 virtual void SAL_CALL acquire() throw () { 111 Base::acquire(); 112 } 113 114 virtual void SAL_CALL release() throw () { 115 Base::release(); 116 } 117 }; 118 119 class Impl2: public Interface2a, public Interface3, private Base { 120 public: 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 145 virtual void SAL_CALL acquire() throw () { 146 Base::acquire(); 147 } 148 149 virtual void SAL_CALL release() throw () { 150 Base::release(); 151 } 152 }; 153 154 class Impl2b: public Interface2b, private Base { 155 public: 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 181 virtual void SAL_CALL acquire() throw () { 182 Base::acquire(); 183 } 184 185 virtual void SAL_CALL release() throw () { 186 Base::release(); 187 } 188 }; 189 190 class Test: public ::testing::Test { 191 public: 192 }; 193 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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