stoc/test/registry_tdprovider/testregistrytdprovider.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
  21 #include <com/sun/star/beans/XPropertySet.hpp>
  22 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  23 #include <com/sun/star/lang/XMain.hpp>
  24 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
  25 #include <com/sun/star/reflection/XCompoundTypeDescription.hpp>
  26 #include <com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp>
  27 #include <com/sun/star/reflection/XInterfaceMemberTypeDescription.hpp>
  28 #include <com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp>
  29 #include <com/sun/star/reflection/XInterfaceTypeDescription2.hpp>
  30 #include <com/sun/star/reflection/XPublished.hpp>
  31 #include <com/sun/star/reflection/XServiceTypeDescription2.hpp>
  32 #include <com/sun/star/reflection/XSingletonTypeDescription2.hpp>
  33 #include <com/sun/star/reflection/XStructTypeDescription.hpp>
  34 #include <com/sun/star/reflection/XTypeDescription.hpp>
  35 #include <com/sun/star/registry/InvalidRegistryException.hpp>
  36 #include <com/sun/star/registry/XRegistryKey.hpp>
  37 #include <com/sun/star/uno/Any.hxx>
  38 #include <com/sun/star/uno/Exception.hpp>
  39 #include <com/sun/star/uno/Reference.hxx>
  40 #include <com/sun/star/uno/RuntimeException.hpp>
  41 #include <com/sun/star/uno/Sequence.hxx>
  42 #include <com/sun/star/uno/TypeClass.hpp>
  43 #include <com/sun/star/uno/XComponentContext.hpp>
  44 #include <com/sun/star/uno/XInterface.hpp>
  45 #include <cppuhelper/factory.hxx>
  46 #include <cppuhelper/implbase1.hxx>
  47 #include <cppuhelper/weak.hxx>
  48 #include <rtl/textenc.h>
  49 #include <rtl/ustring.h>
  50 #include <rtl/ustring.hxx>
  51 #include <sal/types.h>
  52 #include <uno/environment.h>
  53
  54 #include /*MSVC trouble: <cstdlib>*/ <stdlib.h>
  55 #include <iostream>
  56 #include <ostream>
  57
  58 namespace {
  59
  60 class Service: public cppu::WeakImplHelper1< css::lang::XMain > {
  61 public:
  62     virtual sal_Int32 SAL_CALL
  63     run(css::uno::Sequence< OUString > const & arguments)
  64         throw (css::uno::RuntimeException);
  65
  66     static OUString getImplementationName();
  67
  68     static css::uno::Sequence< OUString > getSupportedServiceNames();
  69
  70     static css::uno::Reference< css::uno::XInterface > SAL_CALL createInstance(
  71         css::uno::Reference< css::uno::XComponentContext > const & context)
  72         throw (css::uno::Exception);
  73
  74 private:
  75     explicit Service(
  76         css::uno::Reference< css::uno::XComponentContext > const & context):
  77         m_context(context)
  78     {}
  79
  80     css::uno::Reference< css::uno::XComponentContext > m_context;
  81 };
  82
  83 }
  84
  85 namespace {
  86
  87 std::ostream & operator <<(std::ostream & out, OUString const & value) {
  88     return out << OUStringToOString(value, RTL_TEXTENCODING_UTF8).getStr();
  89 }
  90
  91 void assertTrue(bool argument) {
  92     if (!argument) {
  93         std::cerr
  94             << "assertTrue(" << argument << ") failed" << std::endl;
  95         /*MSVC trouble: std::*/abort();
  96     }
  97 }
  98
  99 void assertFalse(bool argument) {
 100     if (argument) {
 101         std::cerr
 102             << "assertFalse(" << argument << ") failed" << std::endl;
 103         /*MSVC trouble: std::*/abort();
 104     }
 105 }
 106
 107 template< typename T > void assertEqual(T const & value, T const & argument) {
 108     if (argument != value) {
 109         std::cerr
 110             << "assertEqual(" << value << ", " << argument << ") failed"
 111             << std::endl;
 112         /*MSVC trouble: std::*/abort();
 113     }
 114 }
 115
 116 }
 117
 118 sal_Int32 Service::run(css::uno::Sequence< OUString > const &)
 119     throw (css::uno::RuntimeException)
 120 {
 121     css::uno::Reference< css::lang::XMultiComponentFactory > factory(
 122         m_context->getServiceManager());
 123     assertTrue(factory.is());
 124     css::uno::Sequence< css::uno::Any > args(1);
 125     args[0] = css::uno::Reference< css::beans::XPropertySet >(
 126         factory, css::uno::UNO_QUERY_THROW)->getPropertyValue(
 127             OUString("Registry"));
 128     css::uno::Reference< css::container::XHierarchicalNameAccess > provider(
 129         factory->createInstanceWithArgumentsAndContext(
 130             OUString( "com.sun.star.comp.stoc.RegistryTypeDescriptionProvider"),
 131             args, m_context),
 132         css::uno::UNO_QUERY_THROW);
 133
 134     // The following assumes that interface members are sorted by increasing
 135     // values of XInterfaceMemberTypeDescription.getPosition, the exceptions
 136     // of interface attributes and interface methods, the constructors of
 137     // services, and the exceptions of service constructors are sorted as given
 138     // in the UNOIDL source code:
 139
 140     assertEqual< bool >(
 141         false,
 142         provider->hasByHierarchicalName(
 143             OUString( "[][]boolean")));
 144     assertEqual< bool >(
 145         false,
 146         provider->hasByHierarchicalName(
 147             OUString( "test.registrytdprovider.Struct3<boolean,boolean>")));
 148     assertEqual< bool >(
 149         false,
 150         provider->hasByHierarchicalName(
 151             OUString( "com.sun.star.uno.XComponentContext::getValueByName")));
 152
 153     css::uno::Reference< css::reflection::XCompoundTypeDescription > exception;
 154     exception
 155         = css::uno::Reference< css::reflection::XCompoundTypeDescription >(
 156             provider->getByHierarchicalName(
 157                 OUString( "com.sun.star.uno.Exception")),
 158             css::uno::UNO_QUERY_THROW);
 159     assertEqual(css::uno::TypeClass_EXCEPTION, exception->getTypeClass());
 160     assertEqual( OUString( "com.sun.star.uno.Exception"),
 161         exception->getName());
 162     assertFalse(exception->getBaseType().is());
 163     exception
 164         = css::uno::Reference< css::reflection::XCompoundTypeDescription >(
 165             provider->getByHierarchicalName(
 166                 OUString( "com.sun.star.uno.RuntimeException")),
 167             css::uno::UNO_QUERY_THROW);
 168     assertEqual(css::uno::TypeClass_EXCEPTION, exception->getTypeClass());
 169     assertEqual( OUString( "com.sun.star.uno.RuntimeException"),
 170         exception->getName());
 171     assertEqual( OUString( "com.sun.star.uno.Exception"),
 172         exception->getBaseType()->getName());
 173
 174     css::uno::Reference< css::reflection::XStructTypeDescription > structure;
 175
 176     structure = css::uno::Reference< css::reflection::XStructTypeDescription >(
 177         provider->getByHierarchicalName(
 178             OUString( "test.registrytdprovider.Struct2")),
 179         css::uno::UNO_QUERY_THROW);
 180     assertEqual(css::uno::TypeClass_STRUCT, structure->getTypeClass());
 181     assertEqual( OUString( "test.registrytdprovider.Struct2"),
 182         structure->getName());
 183     assertFalse(structure->getBaseType().is());
 184     assertEqual< sal_Int32 >(1, structure->getMemberTypes().getLength());
 185     assertEqual(
 186         OUString( "test.registrytdprovider.Struct1"),
 187         structure->getMemberTypes()[0]->getName());
 188     assertEqual< sal_Int32 >(1, structure->getMemberNames().getLength());
 189     assertEqual(
 190         OUString("s1"),
 191         structure->getMemberNames()[0]);
 192     assertEqual< sal_Int32 >(0, structure->getTypeParameters().getLength());
 193     assertEqual< sal_Int32 >(0, structure->getTypeArguments().getLength());
 194
 195     structure = css::uno::Reference< css::reflection::XStructTypeDescription >(
 196         provider->getByHierarchicalName(
 197             OUString( "test.registrytdprovider.Struct3")),
 198         css::uno::UNO_QUERY_THROW);
 199     assertEqual(css::uno::TypeClass_STRUCT, structure->getTypeClass());
 200     assertEqual(
 201         OUString( "test.registrytdprovider.Struct3"),
 202         structure->getName());
 203     assertFalse(structure->getBaseType().is());
 204     assertEqual< sal_Int32 >(1, structure->getMemberTypes().getLength());
 205     assertEqual(
 206         css::uno::TypeClass_UNKNOWN,
 207         structure->getMemberTypes()[0]->getTypeClass());
 208     assertEqual(
 209         OUString("U"),
 210         structure->getMemberTypes()[0]->getName());
 211     assertEqual< sal_Int32 >(1, structure->getMemberNames().getLength());
 212     assertEqual(
 213         OUString("s2"),
 214         structure->getMemberNames()[0]);
 215     assertEqual< sal_Int32 >(2, structure->getTypeParameters().getLength());
 216     assertEqual(
 217         OUString("T"),
 218         structure->getTypeParameters()[0]);
 219     assertEqual(
 220         OUString("U"),
 221         structure->getTypeParameters()[1]);
 222     assertEqual< sal_Int32 >(0, structure->getTypeArguments().getLength());
 223
 224     structure = css::uno::Reference< css::reflection::XStructTypeDescription >(
 225         provider->getByHierarchicalName(
 226             OUString( "test.registrytdprovider.Struct4")),
 227         css::uno::UNO_QUERY_THROW);
 228     assertEqual(css::uno::TypeClass_STRUCT, structure->getTypeClass());
 229     assertEqual(
 230         OUString( "test.registrytdprovider.Struct4"),
 231         structure->getName());
 232     assertEqual(
 233         OUString( "test.registrytdprovider.Struct2"),
 234         structure->getBaseType()->getName());
 235     assertEqual< sal_Int32 >(1, structure->getMemberTypes().getLength());
 236     assertEqual(
 237         OUString( "test.registrytdprovider.Struct3<"
 238                 "test.registrytdprovider.Struct2,"
 239                 "test.registrytdprovider.Struct3<boolean,any>>"),
 240         structure->getMemberTypes()[0]->getName());
 241     assertEqual< sal_Int32 >(1, structure->getMemberNames().getLength());
 242     assertEqual(
 243         OUString("s2"),
 244         structure->getMemberNames()[0]);
 245     assertEqual< sal_Int32 >(0, structure->getTypeParameters().getLength());
 246     assertEqual< sal_Int32 >(0, structure->getTypeArguments().getLength());
 247
 248     css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >
 249         interface;
 250
 251     interface
 252         = css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
 253             provider->getByHierarchicalName(
 254                 OUString( "test.registrytdprovider.XTest1")),
 255             css::uno::UNO_QUERY_THROW);
 256     assertEqual(css::uno::TypeClass_INTERFACE, interface->getTypeClass());
 257     assertEqual(
 258         OUString( "test.registrytdprovider.XTest1"),
 259         interface->getName());
 260     css::uno::Sequence<
 261         css::uno::Reference< css::reflection::XTypeDescription > > bases(
 262             interface->getBaseTypes());
 263     assertEqual< sal_Int32 >(1, bases.getLength());
 264     assertEqual(
 265         OUString( "com.sun.star.uno.XInterface"),
 266         bases[0]->getName());
 267     css::uno::Sequence<
 268         css::uno::Reference< css::reflection::XTypeDescription > >
 269             optionalBases(interface->getOptionalBaseTypes());
 270     assertEqual< sal_Int32 >(1, optionalBases.getLength());
 271     assertEqual(
 272         OUString(
 273             "test.registrytdprovider.XBase"),
 274         optionalBases[0]->getName());
 275     css::uno::Sequence<
 276         css::uno::Reference<
 277             css::reflection::XInterfaceMemberTypeDescription > > members(
 278                 interface->getMembers());
 279     assertEqual< sal_Int32 >(5, members.getLength());
 280
 281     css::uno::Reference< css::reflection::XInterfaceAttributeTypeDescription2 >
 282         attribute;
 283     css::uno::Sequence<
 284         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 285             getExceptions;
 286     css::uno::Sequence<
 287         css::uno::Reference< css::reflection::XCompoundTypeDescription > >
 288             setExceptions;
 289     css::uno::Reference< css::reflection::XInterfaceMethodTypeDescription >
 290         method;
 291
 292     attribute = css::uno::Reference<
 293         css::reflection::XInterfaceAttributeTypeDescription2 >(
 294             members[0], css::uno::UNO_QUERY_THROW);
 295     assertEqual(
 296         css::uno::TypeClass_INTERFACE_ATTRIBUTE, attribute->getTypeClass());
 297     assertEqual(
 298         OUString( "test.registrytdprovider.XTest1::a1"),
 299         attribute->getName());
 300     assertEqual(
 301         OUString("a1"),
 302         attribute->getMemberName());
 303     assertEqual< sal_Int32 >(3, attribute->getPosition());
 304     assertEqual< bool >(false, attribute->isReadOnly());
 305     assertEqual(
 306         OUString("short"),
 307         attribute->getType()->getName());
 308     assertEqual< bool >(true, attribute->isBound());
 309     getExceptions = attribute->getGetExceptions();
 310     assertEqual< sal_Int32 >(0, getExceptions.getLength());
 311     setExceptions = attribute->getSetExceptions();
 312     assertEqual< sal_Int32 >(0, setExceptions.getLength());
 313
 314     attribute = css::uno::Reference<
 315         css::reflection::XInterfaceAttributeTypeDescription2 >(
 316             members[1], css::uno::UNO_QUERY_THROW);
 317     assertEqual(
 318         css::uno::TypeClass_INTERFACE_ATTRIBUTE, attribute->getTypeClass());
 319     assertEqual(
 320         OUString( "test.registrytdprovider.XTest1::a2"),
 321         attribute->getName());
 322     assertEqual(
 323         OUString("a2"),
 324         attribute->getMemberName());
 325     assertEqual< sal_Int32 >(4, attribute->getPosition());
 326     assertEqual< bool >(false, attribute->isReadOnly());
 327     assertEqual(
 328         OUString("long"),
 329         attribute->getType()->getName());
 330     assertEqual< bool >(false, attribute->isBound());
 331     getExceptions = attribute->getGetExceptions();
 332     assertEqual< sal_Int32 >(2, getExceptions.getLength());
 333     assertEqual(
 334         OUString( "com.sun.star.lang.WrappedTargetException"),
 335         getExceptions[0]->getName());
 336     assertEqual(
 337         OUString( "com.sun.star.uno.RuntimeException"),
 338         getExceptions[1]->getName());
 339     setExceptions = attribute->getSetExceptions();
 340     assertEqual< sal_Int32 >(2, setExceptions.getLength());
 341     assertEqual(
 342         OUString( "com.sun.star.uno.Exception"),
 343         setExceptions[0]->getName());
 344     assertEqual(
 345         OUString( "com.sun.star.lang.WrappedTargetException"),
 346         setExceptions[1]->getName());
 347
 348     attribute = css::uno::Reference<
 349         css::reflection::XInterfaceAttributeTypeDescription2 >(
 350             members[2], css::uno::UNO_QUERY_THROW);
 351     assertEqual(
 352         css::uno::TypeClass_INTERFACE_ATTRIBUTE, attribute->getTypeClass());
 353     assertEqual(
 354         OUString(
 355             "test.registrytdprovider.XTest1::a3"),
 356         attribute->getName());
 357     assertEqual(
 358         OUString("a3"),
 359         attribute->getMemberName());
 360     assertEqual< sal_Int32 >(5, attribute->getPosition());
 361     assertEqual< bool >(true, attribute->isReadOnly());
 362     assertEqual(
 363         OUString("hyper"),
 364         attribute->getType()->getName());
 365     assertEqual< bool >(true, attribute->isBound());
 366     getExceptions = attribute->getGetExceptions();
 367     assertEqual< sal_Int32 >(1, getExceptions.getLength());
 368     assertEqual(
 369         OUString( "com.sun.star.lang.WrappedTargetException"),
 370         getExceptions[0]->getName());
 371     setExceptions = attribute->getSetExceptions();
 372     assertEqual< sal_Int32 >(0, setExceptions.getLength());
 373
 374     method = css::uno::Reference<
 375         css::reflection::XInterfaceMethodTypeDescription >(
 376             members[3], css::uno::UNO_QUERY_THROW);
 377     assertEqual(css::uno::TypeClass_INTERFACE_METHOD, method->getTypeClass());
 378     assertEqual(
 379         OUString( "test.registrytdprovider.XTest1::f1"),
 380         method->getName());
 381     assertEqual(
 382         OUString("f1"),
 383         method->getMemberName());
 384     assertEqual< sal_Int32 >(6, method->getPosition());
 385     assertEqual< bool >(false, method->isOneway());
 386     assertEqual< sal_Int32 >(1, method->getParameters().getLength());
 387     assertEqual(
 388         OUString("p"),
 389         method->getParameters()[0]->getName());
 390     assertEqual(
 391         OUString("any"),
 392         method->getParameters()[0]->getType()->getName());
 393     assertEqual< bool >(false, method->getParameters()[0]->isIn());
 394     assertEqual< bool >(true, method->getParameters()[0]->isOut());
 395     assertEqual< sal_Int32 >(0, method->getParameters()[0]->getPosition());
 396     assertEqual< sal_Int32 >(1, method->getExceptions().getLength());
 397     assertEqual(
 398         OUString( "com.sun.star.uno.RuntimeException"),
 399         method->getExceptions()[0]->getName());
 400
 401     method = css::uno::Reference<
 402         css::reflection::XInterfaceMethodTypeDescription >(
 403             members[4], css::uno::UNO_QUERY_THROW);
 404     assertEqual(css::uno::TypeClass_INTERFACE_METHOD, method->getTypeClass());
 405     assertEqual(
 406         OUString( "test.registrytdprovider.XTest1::f2"),
 407         method->getName());
 408     assertEqual(
 409         OUString("f2"),
 410         method->getMemberName());
 411     assertEqual< sal_Int32 >(7, method->getPosition());
 412     assertEqual< bool >(true, method->isOneway());
 413     assertEqual< sal_Int32 >(0, method->getParameters().getLength());
 414     assertEqual< sal_Int32 >(0, method->getExceptions().getLength());
 415
 416     interface
 417         = css::uno::Reference< css::reflection::XInterfaceTypeDescription2 >(
 418             provider->getByHierarchicalName(
 419                 OUString( "test.registrytdprovider.XTest2")),
 420             css::uno::UNO_QUERY_THROW);
 421     assertEqual(css::uno::TypeClass_INTERFACE, interface->getTypeClass());
 422     assertEqual(
 423         OUString( "test.registrytdprovider.XTest2"),
 424         interface->getName());
 425     assertEqual< sal_Int32 >(1, interface->getBaseTypes().getLength());
 426     assertEqual(
 427         OUString( "test.registrytdprovider.Typedef2"),
 428         interface->getBaseTypes()[0]->getName());
 429     assertEqual< sal_Int32 >(0, interface->getOptionalBaseTypes().getLength());
 430     assertEqual< sal_Int32 >(0, interface->getMembers().getLength());
 431
 432     css::uno::Reference< css::reflection::XServiceTypeDescription2 > service;
 433
 434     service = css::uno::Reference< css::reflection::XServiceTypeDescription2 >(
 435         provider->getByHierarchicalName(
 436             OUString( "test.registrytdprovider.Service1")),
 437         css::uno::UNO_QUERY_THROW);
 438     assertEqual(css::uno::TypeClass_SERVICE, service->getTypeClass());
 439     assertEqual(
 440         OUString( "test.registrytdprovider.Service1"),
 441         service->getName());
 442     assertEqual< sal_Int32 >(0, service->getMandatoryServices().getLength());
 443     assertEqual< sal_Int32 >(0, service->getOptionalServices().getLength());
 444     assertEqual< sal_Int32 >(0, service->getMandatoryInterfaces().getLength());
 445     assertEqual< sal_Int32 >(0, service->getOptionalInterfaces().getLength());
 446     assertEqual< bool >(true, service->isSingleInterfaceBased());
 447     assertEqual(
 448         OUString(
 449             "test.registrytdprovider.XTest1"),
 450         service->getInterface()->getName());
 451     assertEqual< sal_Int32 >(2, service->getConstructors().getLength());
 452     assertEqual(
 453         OUString("c1"),
 454         service->getConstructors()[0]->getName());
 455     assertEqual< sal_Int32 >(
 456         0, service->getConstructors()[0]->getParameters().getLength());
 457     assertEqual< sal_Int32 >(
 458         0, service->getConstructors()[0]->getExceptions().getLength());
 459     assertEqual(
 460         OUString("c2"),
 461         service->getConstructors()[1]->getName());
 462     assertEqual< sal_Int32 >(
 463         1, service->getConstructors()[1]->getParameters().getLength());
 464     assertEqual(
 465         OUString("p"),
 466         service->getConstructors()[1]->getParameters()[0]->getName());
 467     assertEqual(
 468         OUString("any"),
 469         (service->getConstructors()[1]->getParameters()[0]->getType()->
 470          getName()));
 471     assertEqual< bool >(
 472         true, service->getConstructors()[1]->getParameters()[0]->isIn());
 473     assertEqual< bool >(
 474         false, service->getConstructors()[1]->getParameters()[0]->isOut());
 475     assertEqual< sal_Int32 >(
 476         0, service->getConstructors()[1]->getParameters()[0]->getPosition());
 477     assertEqual< bool >(
 478         true,
 479         service->getConstructors()[1]->getParameters()[0]->isRestParameter());
 480     assertEqual< sal_Int32 >(
 481         1, service->getConstructors()[1]->getExceptions().getLength());
 482     assertEqual(
 483         OUString( "com.sun.star.uno.RuntimeException"),
 484         service->getConstructors()[1]->getExceptions()[0]->getName());
 485
 486     service = css::uno::Reference< css::reflection::XServiceTypeDescription2 >(
 487         provider->getByHierarchicalName(
 488             OUString( "test.registrytdprovider.Service2")),
 489         css::uno::UNO_QUERY_THROW);
 490     assertEqual(css::uno::TypeClass_SERVICE, service->getTypeClass());
 491     assertEqual(
 492         OUString( "test.registrytdprovider.Service2"),
 493         service->getName());
 494     assertEqual< sal_Int32 >(0, service->getMandatoryServices().getLength());
 495     assertEqual< sal_Int32 >(0, service->getOptionalServices().getLength());
 496     assertEqual< sal_Int32 >(1, service->getMandatoryInterfaces().getLength());
 497     assertEqual(
 498         OUString( "test.registrytdprovider.XTest1"),
 499         service->getMandatoryInterfaces()[0]->getName());
 500     assertEqual< sal_Int32 >(1, service->getOptionalInterfaces().getLength());
 501     assertEqual(
 502         OUString( "test.registrytdprovider.XBase"),
 503         service->getOptionalInterfaces()[0]->getName());
 504     assertEqual< bool >(false, service->isSingleInterfaceBased());
 505     assertFalse(service->getInterface().is());
 506     assertEqual< sal_Int32 >(0, service->getConstructors().getLength());
 507
 508     service = css::uno::Reference< css::reflection::XServiceTypeDescription2 >(
 509         provider->getByHierarchicalName(
 510             OUString( "test.registrytdprovider.Service3")),
 511         css::uno::UNO_QUERY_THROW);
 512     assertEqual(css::uno::TypeClass_SERVICE, service->getTypeClass());
 513     assertEqual(
 514         OUString(
 515             "test.registrytdprovider.Service3"),
 516         service->getName());
 517     assertEqual< sal_Int32 >(0, service->getMandatoryServices().getLength());
 518     assertEqual< sal_Int32 >(0, service->getOptionalServices().getLength());
 519     assertEqual< sal_Int32 >(0, service->getMandatoryInterfaces().getLength());
 520     assertEqual< sal_Int32 >(0, service->getOptionalInterfaces().getLength());
 521     assertEqual< bool >(true, service->isSingleInterfaceBased());
 522     assertEqual(
 523         OUString(
 524             "test.registrytdprovider.Typedef2"),
 525         service->getInterface()->getName());
 526     assertEqual< sal_Int32 >(0, service->getConstructors().getLength());
 527
 528     css::uno::Reference< css::reflection::XSingletonTypeDescription2 >
 529         singleton;
 530
 531     singleton = css::uno::Reference<
 532         css::reflection::XSingletonTypeDescription2 >(
 533             provider->getByHierarchicalName(
 534                 OUString( "test.registrytdprovider.Singleton1")),
 535             css::uno::UNO_QUERY_THROW);
 536     assertEqual(css::uno::TypeClass_SINGLETON, singleton->getTypeClass());
 537     assertEqual(
 538         OUString(
 539             "test.registrytdprovider.Singleton1"),
 540         singleton->getName());
 541     assertFalse(singleton->getService().is());
 542     assertEqual< bool >(true, singleton->isInterfaceBased());
 543     assertEqual(
 544         OUString(
 545             "test.registrytdprovider.XTest1"),
 546         singleton->getInterface()->getName());
 547
 548     singleton = css::uno::Reference<
 549         css::reflection::XSingletonTypeDescription2 >(
 550             provider->getByHierarchicalName(
 551                 OUString( "test.registrytdprovider.Singleton2")),
 552             css::uno::UNO_QUERY_THROW);
 553     assertEqual(css::uno::TypeClass_SINGLETON, singleton->getTypeClass());
 554     assertEqual(
 555         OUString(
 556             "test.registrytdprovider.Singleton2"),
 557         singleton->getName());
 558     assertEqual(
 559         OUString(
 560             "test.registrytdprovider.Service1"),
 561         singleton->getService()->getName());
 562     assertEqual< bool >(false, singleton->isInterfaceBased());
 563     assertFalse(singleton->getInterface().is());
 564
 565     singleton = css::uno::Reference<
 566         css::reflection::XSingletonTypeDescription2 >(
 567             provider->getByHierarchicalName(
 568                 OUString( "test.registrytdprovider.Singleton3")),
 569             css::uno::UNO_QUERY_THROW);
 570     assertEqual(css::uno::TypeClass_SINGLETON, singleton->getTypeClass());
 571     assertEqual(
 572         OUString(
 573             "test.registrytdprovider.Singleton3"),
 574         singleton->getName());
 575     assertFalse(singleton->getService().is());
 576     assertEqual< bool >(true, singleton->isInterfaceBased());
 577     assertEqual(
 578         OUString(
 579             "test.registrytdprovider.Typedef2"),
 580         singleton->getInterface()->getName());
 581
 582     css::uno::Reference< css::reflection::XPublished > published;
 583     published = css::uno::Reference< css::reflection::XPublished >(
 584         css::uno::Reference< css::reflection::XTypeDescription >(
 585             provider->getByHierarchicalName(
 586                 OUString( "test.registrytdprovider.Enum1")),
 587             css::uno::UNO_QUERY_THROW),
 588         css::uno::UNO_QUERY);
 589     assertTrue(published.is());
 590     assertTrue(published->isPublished());
 591     published = css::uno::Reference< css::reflection::XPublished >(
 592         css::uno::Reference< css::reflection::XTypeDescription >(
 593             provider->getByHierarchicalName(
 594                 OUString( "test.registrytdprovider.Enum2")),
 595             css::uno::UNO_QUERY_THROW),
 596         css::uno::UNO_QUERY);
 597     assertTrue(published.is());
 598     assertFalse(published->isPublished());
 599     published = css::uno::Reference< css::reflection::XPublished >(
 600         css::uno::Reference< css::reflection::XTypeDescription >(
 601             provider->getByHierarchicalName(
 602                 OUString( "test.registrytdprovider.Struct1")),
 603             css::uno::UNO_QUERY_THROW),
 604         css::uno::UNO_QUERY);
 605     assertTrue(published.is());
 606     assertTrue(published->isPublished());
 607     published = css::uno::Reference< css::reflection::XPublished >(
 608         css::uno::Reference< css::reflection::XTypeDescription >(
 609             provider->getByHierarchicalName(
 610                 OUString( "test.registrytdprovider.Struct2")),
 611             css::uno::UNO_QUERY_THROW),
 612         css::uno::UNO_QUERY);
 613     assertTrue(published.is());
 614     assertFalse(published->isPublished());
 615     published = css::uno::Reference< css::reflection::XPublished >(
 616         css::uno::Reference< css::reflection::XTypeDescription >(
 617             provider->getByHierarchicalName(
 618                 OUString( "test.registrytdprovider.Struct3")),
 619             css::uno::UNO_QUERY_THROW),
 620         css::uno::UNO_QUERY);
 621     assertTrue(published.is());
 622     assertTrue(published->isPublished());
 623     published = css::uno::Reference< css::reflection::XPublished >(
 624         css::uno::Reference< css::reflection::XStructTypeDescription >(
 625             provider->getByHierarchicalName(
 626                 OUString( "test.registrytdprovider.Struct3")),
 627             css::uno::UNO_QUERY_THROW)->getMemberTypes()[0],
 628         css::uno::UNO_QUERY);
 629     assertFalse(published.is());
 630     published = css::uno::Reference< css::reflection::XPublished >(
 631         css::uno::Reference< css::reflection::XTypeDescription >(
 632             provider->getByHierarchicalName(
 633                 OUString( "test.registrytdprovider.Struct3a")),
 634             css::uno::UNO_QUERY_THROW),
 635         css::uno::UNO_QUERY);
 636     assertTrue(published.is());
 637     assertFalse(published->isPublished());
 638     published = css::uno::Reference< css::reflection::XPublished >(
 639         css::uno::Reference< css::reflection::XTypeDescription >(
 640             provider->getByHierarchicalName(
 641                 OUString( "test.registrytdprovider.Exception1")),
 642             css::uno::UNO_QUERY_THROW),
 643         css::uno::UNO_QUERY);
 644     assertTrue(published.is());
 645     assertTrue(published->isPublished());
 646     published = css::uno::Reference< css::reflection::XPublished >(
 647         css::uno::Reference< css::reflection::XTypeDescription >(
 648             provider->getByHierarchicalName(
 649                 OUString( "test.registrytdprovider.Exception2")),
 650             css::uno::UNO_QUERY_THROW),
 651         css::uno::UNO_QUERY);
 652     assertTrue(published.is());
 653     assertFalse(published->isPublished());
 654     published = css::uno::Reference< css::reflection::XPublished >(
 655         css::uno::Reference< css::reflection::XTypeDescription >(
 656             provider->getByHierarchicalName(
 657                 OUString( "test.registrytdprovider.XTest1")),
 658             css::uno::UNO_QUERY_THROW),
 659         css::uno::UNO_QUERY);
 660     assertTrue(published.is());
 661     assertTrue(published->isPublished());
 662     published = css::uno::Reference< css::reflection::XPublished >(
 663         css::uno::Reference< css::reflection::XTypeDescription >(
 664             provider->getByHierarchicalName(
 665                 OUString( "test.registrytdprovider.XTest2")),
 666             css::uno::UNO_QUERY_THROW),
 667         css::uno::UNO_QUERY);
 668     assertTrue(published.is());
 669     assertFalse(published->isPublished());
 670     published = css::uno::Reference< css::reflection::XPublished >(
 671         css::uno::Reference< css::reflection::XTypeDescription >(
 672             provider->getByHierarchicalName(
 673                 OUString( "test.registrytdprovider.Typedef1")),
 674             css::uno::UNO_QUERY_THROW),
 675         css::uno::UNO_QUERY);
 676     assertTrue(published.is());
 677     assertTrue(published->isPublished());
 678     published = css::uno::Reference< css::reflection::XPublished >(
 679         css::uno::Reference< css::reflection::XTypeDescription >(
 680             provider->getByHierarchicalName(
 681                 OUString( "test.registrytdprovider.Typedef2")),
 682             css::uno::UNO_QUERY_THROW),
 683         css::uno::UNO_QUERY);
 684     assertTrue(published.is());
 685     assertFalse(published->isPublished());
 686     //TODO: check constants test.registrytdprovider.Const1 (published),
 687     // test.registrytdprovider.Const2 (unpublished), and
 688     // test.registrytdprovider.Consts1.C (no XPublished), which are not
 689     // accessible via provider->getByHierarchicalName (see #i31428)
 690     published = css::uno::Reference< css::reflection::XPublished >(
 691         css::uno::Reference< css::reflection::XTypeDescription >(
 692             provider->getByHierarchicalName(
 693                 OUString( "test.registrytdprovider.Consts1")),
 694             css::uno::UNO_QUERY_THROW),
 695         css::uno::UNO_QUERY);
 696     assertTrue(published.is());
 697     assertTrue(published->isPublished());
 698     published = css::uno::Reference< css::reflection::XPublished >(
 699         css::uno::Reference< css::reflection::XTypeDescription >(
 700             provider->getByHierarchicalName(
 701                 OUString( "test.registrytdprovider.Consts2")),
 702             css::uno::UNO_QUERY_THROW),
 703         css::uno::UNO_QUERY);
 704     assertTrue(published.is());
 705     assertFalse(published->isPublished());
 706     published = css::uno::Reference< css::reflection::XPublished >(
 707         css::uno::Reference< css::reflection::XTypeDescription >(
 708             provider->getByHierarchicalName(
 709                 OUString( "test.registrytdprovider")),
 710             css::uno::UNO_QUERY_THROW),
 711         css::uno::UNO_QUERY);
 712     assertFalse(published.is());
 713     published = css::uno::Reference< css::reflection::XPublished >(
 714         css::uno::Reference< css::reflection::XTypeDescription >(
 715             provider->getByHierarchicalName(
 716                 OUString( "test.registrytdprovider.Service1")),
 717             css::uno::UNO_QUERY_THROW),
 718         css::uno::UNO_QUERY);
 719     assertTrue(published.is());
 720     assertTrue(published->isPublished());
 721     published = css::uno::Reference< css::reflection::XPublished >(
 722         css::uno::Reference< css::reflection::XTypeDescription >(
 723             provider->getByHierarchicalName(
 724                 OUString( "test.registrytdprovider.Service2")),
 725             css::uno::UNO_QUERY_THROW),
 726         css::uno::UNO_QUERY);
 727     assertTrue(published.is());
 728     assertFalse(published->isPublished());
 729     published = css::uno::Reference< css::reflection::XPublished >(
 730         css::uno::Reference< css::reflection::XTypeDescription >(
 731             provider->getByHierarchicalName(
 732                 OUString( "test.registrytdprovider.Singleton2")),
 733             css::uno::UNO_QUERY_THROW),
 734         css::uno::UNO_QUERY);
 735     assertTrue(published.is());
 736     assertTrue(published->isPublished());
 737     published = css::uno::Reference< css::reflection::XPublished >(
 738         css::uno::Reference< css::reflection::XTypeDescription >(
 739             provider->getByHierarchicalName(
 740                 OUString( "test.registrytdprovider.Singleton1")),
 741             css::uno::UNO_QUERY_THROW),
 742         css::uno::UNO_QUERY);
 743     assertTrue(published.is());
 744     assertFalse(published->isPublished());
 745
 746     return 0;
 747 }
 748
 749 OUString Service::getImplementationName() {
 750     return OUString("test.registrytdprovider.impl");
 751 }
 752
 753 css::uno::Sequence< OUString > Service::getSupportedServiceNames() {
 754     return css::uno::Sequence< OUString >();
 755 }
 756
 757 css::uno::Reference< css::uno::XInterface > Service::createInstance(
 758     css::uno::Reference< css::uno::XComponentContext > const & context)
 759     throw (css::uno::Exception)
 760 {
 761     return static_cast< cppu::OWeakObject * >(new Service(context));
 762 }
 763
 764 extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory(char const * implName,
 765                                                 void * serviceManager, void *) {
 766     void * p = 0;
 767     if (serviceManager != 0) {
 768         css::uno::Reference< css::lang::XSingleComponentFactory > f;
 769         if (Service::getImplementationName().equalsAscii(implName)) {
 770             f = cppu::createSingleComponentFactory(
 771                 &Service::createInstance, Service::getImplementationName(),
 772                 Service::getSupportedServiceNames());
 773         }
 774         if (f.is()) {
 775             f->acquire();
 776             p = f.get();
 777         }
 778     }
 779     return p;
 780 }
 781
 782 namespace {
 783
 784 bool writeInfo(void * registryKey, OUString const & implementationName,
 785                css::uno::Sequence< OUString > const & serviceNames) {
 786     OUString keyName = "/" + implementationName + "/UNO/SERVICES";
 787     css::uno::Reference< css::registry::XRegistryKey > key;
 788     try {
 789         key = static_cast< css::registry::XRegistryKey * >(registryKey)->
 790             createKey(keyName);
 791     } catch (css::registry::InvalidRegistryException &) {}
 792     if (!key.is()) {
 793         return false;
 794     }
 795     bool success = true;
 796     for (sal_Int32 i = 0; i < serviceNames.getLength(); ++i) {
 797         try {
 798             key->createKey(serviceNames[i]);
 799         } catch (css::registry::InvalidRegistryException &) {
 800             success = false;
 801             break;
 802         }
 803     }
 804     return success;
 805 }
 806
 807 }
 808
 809 extern "C" sal_Bool SAL_CALL component_writeInfo(void *, void * registryKey) {
 810     return registryKey
 811         && writeInfo(registryKey, Service::getImplementationName(),
 812                      Service::getSupportedServiceNames());
 813 }
 814
 815 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */