cppu/qa/test_reference.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/types.h>
  21
  22 #include <cppunit/TestFixture.h>
  23 #include <cppunit/plugin/TestPlugIn.h>
  24 #include <cppunit/extensions/HelperMacros.h>
  25
  26 #include <Interface1.hpp>
  27
  28 namespace
  29 {
  30
  31 using ::com::sun::star::uno::Type;
  32 using ::com::sun::star::uno::Any;
  33 using ::com::sun::star::uno::Reference;
  34 using ::com::sun::star::uno::RuntimeException;
  35 using ::com::sun::star::uno::UNO_SET_THROW;
  36
  37 class Foo: public Interface1
  38 {
  39 public:
  40     Foo()
  41         :m_refCount(0)
  42     {
  43     }
  44
  45     Foo(const Foo&) = delete;
  46     const Foo& operator=(const Foo&) = delete;
  47
  48     virtual Any SAL_CALL queryInterface(const Type & _type) override
  49     {
  50         if (_type == cppu::UnoType<XInterface>::get())
  51         {
  52             return css::uno::Any(css::uno::Reference<css::uno::XInterface>(
  53                 this));
  54         }
  55         if (_type == cppu::UnoType<Interface1>::get())
  56         {
  57             return css::uno::Any(css::uno::Reference<Interface1>(this));
  58         }
  59
  60         return Any();
  61     }
  62
  63     virtual void SAL_CALL acquire() noexcept override
  64     {
  65         osl_atomic_increment( &m_refCount );
  66     }
  67
  68     virtual void SAL_CALL release() noexcept override
  69     {
  70         if ( 0 == osl_atomic_decrement( &m_refCount ) )
  71             delete this;
  72     }
  73
  74 protected:
  75     virtual ~Foo()
  76     {
  77     }
  78
  79 private:
  80     oslInterlockedCount m_refCount;
  81 };
  82
  83 // Check that the up-casting Reference conversion constructor catches the
  84 // intended cases:
  85
  86 struct Base1: public css::uno::XInterface {
  87     virtual ~Base1() = delete;
  88     static ::css::uno::Type const & static_type(void * = nullptr) // loplugin:refcounting
  89     { return ::cppu::UnoType<Base1>::get(); }
  90 };
  91 struct Base2: public Base1 {
  92     virtual ~Base2() override = delete;
  93 };
  94 struct Base3: public Base1 { virtual ~Base3() override = delete; };
  95 struct Derived: public Base2, public Base3 {
  96     virtual ~Derived() override = delete;
  97 };
  98
  99 // The special case using the conversion operator instead:
 100 css::uno::Reference< css::uno::XInterface > testUpcast1(
 101     css::uno::Reference< Derived > const & ref)
 102 {
 103     Base1::static_type(); // prevent loplugin:unreffun firing
 104     return ref;
 105 }
 106
 107 // The normal up-cast case:
 108 css::uno::Reference< Base1 > testUpcast2(
 109     css::uno::Reference< Base2 > const & ref)
 110 { return ref; }
 111
 112 // Commenting this in should cause a compiler error due to an ambiguous up-cast:
 113 /*
 114 css::uno::Reference< Base1 > testFailingUpcast3(
 115     css::uno::Reference< Derived > const & ref)
 116 { return ref; }
 117 */
 118
 119 // Commenting this in should cause a compiler error due to a down-cast:
 120 /*
 121 css::uno::Reference< Base2 > testFailingUpcast4(
 122     css::uno::Reference< Base1 > const & ref)
 123 { return ref; }
 124 */
 125
 126 // Commenting this in should cause a compiler error due to a down-cast:
 127 /*
 128 css::uno::Reference< Base1 > testFailingUpcast5(
 129     css::uno::Reference< css::uno::XInterface > const & ref)
 130 { return ref; }
 131 */
 132
 133 class Test: public ::CppUnit::TestFixture
 134 {
 135
 136 public:
 137     void testUnoSetThrow();
 138     void testUpcastCompilation();
 139
 140     CPPUNIT_TEST_SUITE(Test);
 141     CPPUNIT_TEST(testUnoSetThrow);
 142     CPPUNIT_TEST(testUpcastCompilation);
 143     CPPUNIT_TEST_SUITE_END();
 144 };
 145
 146 void Test::testUnoSetThrow()
 147 {
 148     Reference< Interface1 > xNull;
 149     Reference< Interface1 > xFoo( new Foo );
 150
 151     // ctor taking Reference< interface_type >
 152     bool bCaughtException = false;
 153     try { Reference< Interface1 > x( xNull, UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 154     CPPUNIT_ASSERT_EQUAL( true, bCaughtException );
 155
 156     bCaughtException = false;
 157     try { Reference< Interface1 > x( xFoo, UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 158     CPPUNIT_ASSERT_EQUAL( false, bCaughtException );
 159
 160     // ctor taking interface_type*
 161     bCaughtException = false;
 162     try { Reference< Interface1 > x( xNull.get(), UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 163     CPPUNIT_ASSERT_EQUAL( true, bCaughtException );
 164
 165     bCaughtException = false;
 166     try { Reference< Interface1 > x( xFoo.get(), UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 167     CPPUNIT_ASSERT_EQUAL( false, bCaughtException );
 168
 169     Reference< Interface1 > x;
 170     // "set" taking Reference< interface_type >
 171     bCaughtException = false;
 172     try { x.set( xNull, UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 173     CPPUNIT_ASSERT_EQUAL( true, bCaughtException );
 174
 175     bCaughtException = false;
 176     try { x.set( xFoo, UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 177     CPPUNIT_ASSERT_EQUAL( false, bCaughtException );
 178
 179     // "set" taking interface_type*
 180     bCaughtException = false;
 181     try { x.set( xNull.get(), UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 182     CPPUNIT_ASSERT_EQUAL( true, bCaughtException );
 183
 184     bCaughtException = false;
 185     try { x.set( xFoo.get(), UNO_SET_THROW ); } catch( const RuntimeException& ) { bCaughtException = true; }
 186     CPPUNIT_ASSERT_EQUAL( false, bCaughtException );
 187 }
 188
 189 // Include a dummy test calling those functions, to avoid warnings about those
 190 // functions being unused:
 191 void Test::testUpcastCompilation()
 192 {
 193     testUpcast1(css::uno::Reference< Derived >());
 194     testUpcast2(css::uno::Reference< Base2 >());
 195 }
 196
 197 CPPUNIT_TEST_SUITE_REGISTRATION(Test);
 198
 199 }   // namespace
 200
 201 CPPUNIT_PLUGIN_IMPLEMENT();
 202
 203 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */