test/source/beans/xpropertyset.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
  10 #include "test/beans/xpropertyset.hxx"
  11 #include "cppunit/extensions/HelperMacros.h"
  12
  13 #include <com/sun/star/uno/Type.h>
  14 #include <com/sun/star/beans/PropertyAttribute.hpp>
  15 #include <com/sun/star/util/DateTime.hpp>
  16
  17 #include <set>
  18
  19 using namespace css;
  20 using namespace css::uno;
  21
  22 namespace apitest {
  23
  24 XPropertySet::~XPropertySet() {}
  25
  26 XPropertySet::PropsToTest::PropsToTest() : initialized(false) {}
  27
  28 void XPropertySet::testGetPropertySetInfo()
  29 {
  30     uno::Reference<beans::XPropertySet> xPropSet(init(), UNO_QUERY_THROW);
  31     uno::Reference<beans::XPropertySetInfo> xPropInfo = xPropSet->getPropertySetInfo();
  32     if (xPropInfo.is())
  33     {
  34         fillPropsToTest(xPropInfo);
  35     }
  36     else
  37     {
  38         // TODO: Add a means for the client code to populate the PropsToTest.
  39     }
  40 }
  41
  42 void XPropertySet::testSetPropertyValue()
  43 {
  44     testGetPropertySetInfo();
  45
  46     for (size_t i = 0, n = maPropsToTest.normal.size(); i < n; ++i)
  47     {
  48         bool bSuccess = isPropertyValueChangeable(maPropsToTest.normal[i]);
  49         CPPUNIT_ASSERT(bSuccess);
  50     }
  51 }
  52
  53 void XPropertySet::testGetPropertyValue()
  54 {
  55     testGetPropertySetInfo();
  56     uno::Reference<beans::XPropertySet> xPropSet(init(), UNO_QUERY_THROW);
  57
  58     // Check read-only properties.
  59     for (size_t i = 0, n = maPropsToTest.readonly.size(); i < n; ++i)
  60     {
  61         bool bSuccess = getSinglePropertyValue(xPropSet, maPropsToTest.readonly[i]);
  62         CPPUNIT_ASSERT(bSuccess);
  63     }
  64
  65     // Check writable properties.
  66     for (size_t i = 0, n = maPropsToTest.normal.size(); i < n; ++i)
  67     {
  68         bool bSuccess = getSinglePropertyValue(xPropSet, maPropsToTest.normal[i]);
  69         CPPUNIT_ASSERT(bSuccess);
  70     }
  71 }
  72
  73 bool XPropertySet::isPropertyValueChangeable(const OUString& rName)
  74 {
  75     uno::Reference<beans::XPropertySet> xPropSet(init(), UNO_QUERY_THROW);
  76     try
  77     {
  78         uno::Any any = xPropSet->getPropertyValue(rName);
  79         uno::Type type = any.getValueType();
  80         if (type == cppu::UnoType<bool>::get())
  81         {
  82             // boolean type
  83             bool bOld = any.get<sal_Bool>();
  84             xPropSet->setPropertyValue(rName, makeAny(!bOld));
  85         }
  86         else if (type == cppu::UnoType<sal_Int8>::get())
  87         {
  88             // 8-bit integer
  89             sal_Int8 nOld = any.get<sal_Int8>();
  90             sal_Int8 nNew = nOld + 1;
  91             xPropSet->setPropertyValue(rName, makeAny(nNew));
  92         }
  93         else if (type == cppu::UnoType<sal_Int16>::get())
  94         {
  95             // 16-bit integer
  96             sal_Int16 nOld = any.get<sal_Int16>();
  97             sal_Int16 nNew = nOld + 2;
  98             xPropSet->setPropertyValue(rName, makeAny(nNew));
  99         }
 100         else if (type == cppu::UnoType<sal_Int32>::get())
 101         {
 102             // 32-bit integer
 103             sal_Int32 nOld = any.get<sal_Int32>();
 104             sal_Int32 nNew = nOld + 3;
 105             xPropSet->setPropertyValue(rName, makeAny(nNew));
 106         }
 107         else if (type == cppu::UnoType<sal_Int64>::get())
 108         {
 109             // 64-bit integer
 110             sal_Int64 nOld = any.get<sal_Int64>();
 111             sal_Int64 nNew = nOld + 4;
 112             xPropSet->setPropertyValue(rName, makeAny(nNew));
 113         }
 114         else if (type == cppu::UnoType<float>::get())
 115         {
 116             // single precision
 117             float fOld = any.get<float>();
 118             float fNew = fOld + 1.2;
 119             xPropSet->setPropertyValue(rName, makeAny(fNew));
 120         }
 121         else if (type == cppu::UnoType<double>::get())
 122         {
 123             // double precision
 124             double fOld = any.get<double>();
 125             double fNew = fOld + 1.3;
 126             xPropSet->setPropertyValue(rName, makeAny(fNew));
 127         }
 128         else if (type == cppu::UnoType<OUString>::get())
 129         {
 130             // string type
 131             OUString aOld = any.get<OUString>();
 132             OUString aNew = aOld + "foo";
 133             xPropSet->setPropertyValue(rName, makeAny(aNew));
 134         }
 135         else if (type == cppu::UnoType<util::DateTime>::get())
 136         {
 137             // date time type
 138             util::DateTime aDT = any.get<util::DateTime>();
 139             aDT.Year += 1;
 140             xPropSet->setPropertyValue(rName, makeAny(aDT));
 141         }
 142         else
 143         {
 144             CPPUNIT_ASSERT_MESSAGE("XPropertySet::isChangeable: unknown type in Any tested.", false);
 145         }
 146
 147         uno::Any anyTest = xPropSet->getPropertyValue(rName);
 148         return any != anyTest;
 149     }
 150     catch (const uno::Exception&)
 151     {
 152         CPPUNIT_ASSERT_MESSAGE("XPropertySet::isChangeable: exception thrown while retrieving the property value.", false);
 153     }
 154
 155     return false;
 156 }
 157
 158 void XPropertySet::fillPropsToTest(const uno::Reference<beans::XPropertySetInfo>& xPropInfo)
 159 {
 160     if (maPropsToTest.initialized)
 161         return;
 162
 163     uno::Sequence<beans::Property> aProps = xPropInfo->getProperties();
 164
 165     // some properties should not be changed in a unspecific way.
 166     // TODO: Maybe we should mark these properties read-only, instead of
 167     // giving them a special treatment here?
 168     std::set<OUString> aSkip;
 169     aSkip.insert("PrinterName");
 170     aSkip.insert("CharRelief");
 171     aSkip.insert("IsLayerMode");
 172
 173     for (sal_Int32 i = 0; i < aProps.getLength(); ++i)
 174     {
 175         beans::Property aProp = aProps[i];
 176         if (aSkip.count(aProp.Name) > 0)
 177             continue;
 178
 179         if ((aProp.Attributes & beans::PropertyAttribute::READONLY) != 0)
 180         {
 181             maPropsToTest.readonly.push_back(aProp.Name);
 182             continue;
 183         }
 184
 185         if ((aProp.Attributes & beans::PropertyAttribute::MAYBEVOID) != 0)
 186             continue;
 187
 188         bool bBound       = (aProp.Attributes & beans::PropertyAttribute::BOUND) != 0;
 189         bool bConstrained = (aProp.Attributes & beans::PropertyAttribute::CONSTRAINED) != 0;
 190         bool bCanChange = isPropertyValueChangeable(aProp.Name);
 191
 192         if (bBound && bCanChange)
 193             maPropsToTest.bound.push_back(aProp.Name);
 194
 195         if (bConstrained && bCanChange)
 196             maPropsToTest.constrained.push_back(aProp.Name);
 197
 198         if (bCanChange)
 199             maPropsToTest.normal.push_back(aProp.Name);
 200     }
 201
 202     maPropsToTest.initialized = true;
 203 }
 204
 205 bool XPropertySet::getSinglePropertyValue(
 206     const uno::Reference<beans::XPropertySet>& xPropSet, const OUString& rName)
 207 {
 208     try
 209     {
 210         xPropSet->getPropertyValue(rName);
 211         return true;
 212     }
 213     catch (const uno::Exception&)
 214     {
 215     }
 216     return false;
 217 }
 218
 219 }
 220
 221 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */