cppuhelper/qa/ifcontainer/cppu_ifcontainer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: cppu_ifcontainer.cxx,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <cppunit/simpleheader.hxx>
  32
  33 #include "com/sun/star/lang/XEventListener.hpp"
  34 #include "cppuhelper/interfacecontainer.hxx"
  35 #include "cppuhelper/queryinterface.hxx"
  36 #include "cppuhelper/implbase1.hxx"
  37 #include "cppuhelper/propshlp.hxx"
  38
  39 using namespace com::sun::star;
  40 using namespace com::sun::star::uno;
  41 using namespace com::sun::star::lang;
  42
  43
  44 struct equalStr
  45 {
  46     bool operator()(
  47         const char * const &rA,
  48         const char * const &rB) const
  49         { return !strcmp(rA, rB); }
  50 };
  51 struct hashStr
  52 {
  53     size_t operator()( const char * &rName ) const
  54     {
  55         return rtl::OString(rName).hashCode();
  56     }
  57 };
  58
  59 class ContainerListener;
  60
  61 struct ContainerStats {
  62     int m_nAlive;
  63     int m_nDisposed;
  64     ContainerStats() : m_nAlive(0), m_nDisposed(0) {}
  65 };
  66
  67 class ContainerListener : public ::cppu::WeakImplHelper1< XEventListener >
  68 {
  69     ContainerStats *m_pStats;
  70 public:
  71     ContainerListener(ContainerStats *pStats)
  72         : m_pStats(pStats) { m_pStats->m_nAlive++; }
  73     virtual ~ContainerListener() { m_pStats->m_nAlive--; }
  74     virtual void SAL_CALL disposing( const EventObject& )
  75         throw (RuntimeException)
  76     {
  77         m_pStats->m_nDisposed++;
  78     }
  79 };
  80
  81 namespace cppu_ifcontainer
  82 {
  83     class IfTest : public CppUnit::TestFixture
  84     {
  85         osl::Mutex m_aGuard;
  86         static const int nTests = 10;
  87     public:
  88         void testCreateDispose()
  89         {
  90             ContainerStats aStats;
  91             cppu::OInterfaceContainerHelper *pContainer;
  92
  93             pContainer = new cppu::OInterfaceContainerHelper(m_aGuard);
  94
  95             CPPUNIT_ASSERT_MESSAGE("Empty container not empty",
  96                                    pContainer->getLength() == 0);
  97
  98             int i;
  99             for (i = 0; i < nTests; i++)
 100             {
 101                 Reference<XEventListener> xRef = new ContainerListener(&aStats);
 102                 int nNewLen = pContainer->addInterface(xRef);
 103
 104                 CPPUNIT_ASSERT_MESSAGE("addition length mismatch",
 105                                        nNewLen == i + 1);
 106                 CPPUNIT_ASSERT_MESSAGE("addition length mismatch",
 107                                        pContainer->getLength() == i + 1);
 108             }
 109             CPPUNIT_ASSERT_MESSAGE("alive count mismatch",
 110                                    aStats.m_nAlive == nTests);
 111
 112             EventObject aObj;
 113             pContainer->disposeAndClear(aObj);
 114
 115             CPPUNIT_ASSERT_MESSAGE("dispose count mismatch",
 116                                    aStats.m_nDisposed == nTests);
 117             CPPUNIT_ASSERT_MESSAGE("leaked container left alive",
 118                                    aStats.m_nAlive == 0);
 119
 120             delete pContainer;
 121         }
 122
 123         void testEnumerate()
 124         {
 125             int i;
 126             ContainerStats aStats;
 127             cppu::OInterfaceContainerHelper *pContainer;
 128             pContainer = new cppu::OInterfaceContainerHelper(m_aGuard);
 129
 130             std::vector< Reference< XEventListener > > aListeners;
 131             for (i = 0; i < nTests; i++)
 132             {
 133                 Reference<XEventListener> xRef = new ContainerListener(&aStats);
 134                 int nNewLen = pContainer->addInterface(xRef);
 135                 aListeners.push_back(xRef);
 136             }
 137             Sequence< Reference< XInterface > > aElements;
 138             aElements = pContainer->getElements();
 139
 140             CPPUNIT_ASSERT_MESSAGE("query contents",
 141                                    (int)aElements.getLength() == nTests);
 142             if ((int)aElements.getLength() == nTests)
 143             {
 144                 for (i = 0; i < nTests; i++)
 145                 {
 146                     CPPUNIT_ASSERT_MESSAGE("mismatching elements",
 147                                            aElements[i] == aListeners[i]);
 148                 }
 149             }
 150             pContainer->clear();
 151
 152             CPPUNIT_ASSERT_MESSAGE("non-empty container post clear",
 153                                    pContainer->getLength() == 0);
 154             delete pContainer;
 155         }
 156
 157         template < typename ContainerType, typename ContainedType >
 158         void doContainerTest(const ContainedType *pTypes)
 159         {
 160             ContainerStats aStats;
 161             ContainerType *pContainer;
 162             pContainer = new ContainerType(m_aGuard);
 163
 164             int i;
 165             Reference<XEventListener> xRefs[nTests * 2];
 166
 167             // add these interfaces
 168             for (i = 0; i < nTests * 2; i++)
 169             {
 170                 xRefs[i] = new ContainerListener(&aStats);
 171                 pContainer->addInterface(pTypes[i / 2], xRefs[i]);
 172             }
 173
 174             // check it is all there
 175             for (i = 0; i < nTests; i++)
 176             {
 177                 cppu::OInterfaceContainerHelper *pHelper;
 178
 179                 pHelper = pContainer->getContainer(pTypes[i]);
 180
 181                 CPPUNIT_ASSERT_MESSAGE("no helper", pHelper != NULL);
 182                 Sequence<Reference< XInterface > > aSeq = pHelper->getElements();
 183                 CPPUNIT_ASSERT_MESSAGE("wrong num elements", aSeq.getLength() == 2);
 184                 CPPUNIT_ASSERT_MESSAGE("match", aSeq[0] == xRefs[i*2]);
 185                 CPPUNIT_ASSERT_MESSAGE("match", aSeq[1] == xRefs[i*2+1]);
 186             }
 187
 188             // remove every other interface
 189             for (i = 0; i < nTests; i++)
 190                 pContainer->removeInterface(pTypes[i], xRefs[i*2+1]);
 191
 192             // check it is half there
 193             for (i = 0; i < nTests; i++)
 194             {
 195                 cppu::OInterfaceContainerHelper *pHelper;
 196
 197                 pHelper = pContainer->getContainer(pTypes[i]);
 198
 199                 CPPUNIT_ASSERT_MESSAGE("no helper", pHelper != NULL);
 200                 Sequence<Reference< XInterface > > aSeq = pHelper->getElements();
 201                 CPPUNIT_ASSERT_MESSAGE("wrong num elements", aSeq.getLength() == 1);
 202                 CPPUNIT_ASSERT_MESSAGE("match", aSeq[0] == xRefs[i*2]);
 203             }
 204
 205             // remove the 1st half of the rest
 206             for (i = 0; i < nTests / 2; i++)
 207                 pContainer->removeInterface(pTypes[i], xRefs[i*2]);
 208
 209             // check it is half there
 210             for (i = 0; i < nTests / 2; i++)
 211             {
 212                 cppu::OInterfaceContainerHelper *pHelper;
 213
 214                 pHelper = pContainer->getContainer(pTypes[i]);
 215                 CPPUNIT_ASSERT_MESSAGE("no helper", pHelper != NULL);
 216                 Sequence<Reference< XInterface > > aSeq = pHelper->getElements();
 217                 CPPUNIT_ASSERT_MESSAGE("wrong num elements", aSeq.getLength() == 0);
 218             }
 219
 220             delete pContainer;
 221         }
 222
 223         void testOMultiTypeInterfaceContainerHelper()
 224         {
 225             uno::Type pTypes[nTests] =
 226             {
 227                 ::cppu::UnoType< bool >::get(),
 228                 ::cppu::UnoType< float >::get(),
 229                 ::cppu::UnoType< double >::get(),
 230                 ::cppu::UnoType< ::sal_uInt64 >::get(),
 231                 ::cppu::UnoType< ::sal_Int64 >::get(),
 232                 ::cppu::UnoType< ::sal_uInt32 >::get(),
 233                 ::cppu::UnoType< ::sal_Int32 >::get(),
 234                 ::cppu::UnoType< ::sal_Int16 >::get(),
 235                 ::cppu::UnoType< ::rtl::OUString >::get(),
 236                 ::cppu::UnoType< ::sal_Int8 >::get()
 237             };
 238             doContainerTest< cppu::OMultiTypeInterfaceContainerHelper,
 239                 uno::Type> (pTypes);
 240         }
 241
 242         void testOMultiTypeInterfaceContainerHelperInt32()
 243         {
 244             sal_Int32 pTypes[nTests] =
 245             {
 246                 0,
 247                 -1,
 248                 1,
 249                 256,
 250                 1024,
 251                 3,
 252                 7,
 253                 8,
 254                 9,
 255                 10
 256             };
 257             doContainerTest< cppu::OMultiTypeInterfaceContainerHelperInt32, sal_Int32> (pTypes);
 258         }
 259
 260         void testOMultiTypeInterfaceContainerHelperVar()
 261         {
 262             typedef ::cppu::OMultiTypeInterfaceContainerHelperVar<
 263                 const char *,hashStr,equalStr> StrContainer;
 264
 265             const char *pTypes[nTests] =
 266             {
 267                 "this_is", "such", "fun", "writing", "unit", "tests", "when", "it", "works", "anyway"
 268             };
 269             doContainerTest< StrContainer, const char *> (pTypes);
 270         }
 271
 272         // Automatic registration code
 273         CPPUNIT_TEST_SUITE(IfTest);
 274         CPPUNIT_TEST(testCreateDispose);
 275         CPPUNIT_TEST(testEnumerate);
 276         CPPUNIT_TEST(testOMultiTypeInterfaceContainerHelper);
 277         CPPUNIT_TEST(testOMultiTypeInterfaceContainerHelperVar);
 278         CPPUNIT_TEST(testOMultiTypeInterfaceContainerHelperInt32);
 279         CPPUNIT_TEST_SUITE_END();
 280     };
 281 } // namespace cppu_ifcontainer
 282
 283 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(cppu_ifcontainer::IfTest,
 284                                       "cppu_ifcontainer");
 285
 286 NOADDITIONAL;