xref: /trunk/main/stoc/test/testintrosp.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_stoc.hxx"
30 
31 #include <sal/main.h>
32 #include <cppuhelper/implbase1.hxx>
33 #include <cppuhelper/implbase4.hxx>
34 #include <cppuhelper/servicefactory.hxx>
35 #include <osl/diagnose.h>
36 
37 //#include <vos/dynload.hxx>
38 
39 #include <ModuleA/XIntroTest.hpp>
40 #include <com/sun/star/beans/XPropertySet.hpp>
41 #include <com/sun/star/beans/XIntrospection.hpp>
42 #include <com/sun/star/beans/PropertyAttribute.hpp>
43 #include <com/sun/star/beans/PropertyConcept.hpp>
44 #include <com/sun/star/beans/MethodConcept.hpp>
45 #include <com/sun/star/beans/XExactName.hpp>
46 #include <com/sun/star/container/XElementAccess.hpp>
47 #include <com/sun/star/container/XNameAccess.hpp>
48 #include <com/sun/star/container/XIndexAccess.hpp>
49 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
50 #include <com/sun/star/reflection/XIdlReflection.hpp>
51 //#include <com/sun/star/registry/XSimpleRegistry.hpp>
52 #include <com/sun/star/registry/XImplementationRegistration.hpp>
53 #include <com/sun/star/lang/XComponent.hpp>
54 
55 #include <stdio.h>
56 #include <string.h>
57 
58 
59 using namespace rtl;
60 using namespace cppu;
61 //using namespace vos;
62 using namespace ModuleA;
63 //using namespace ModuleB;
64 //using namespace ModuleC;
65 //using namespace ModuleA::ModuleB;
66 using namespace com::sun::star::uno;
67 using namespace com::sun::star::lang;
68 using namespace com::sun::star::beans;
69 using namespace com::sun::star::registry;
70 using namespace com::sun::star::reflection;
71 using namespace com::sun::star::container;
72 using namespace com::sun::star::beans::PropertyAttribute;
73 
74 
75 typedef WeakImplHelper4< XIntroTest, XPropertySet, XNameAccess, XIndexAccess > ImplIntroTestHelper;
76 typedef WeakImplHelper1< XPropertySetInfo > ImplPropertySetInfoHelper;
77 
78 
79 #define DEFAULT_INDEX_ACCESS_COUNT  10
80 #define DEFAULT_NAME_ACCESS_COUNT   5
81 
82 #if OSL_DEBUG_LEVEL > 0
83 #define TEST_ENSHURE(c, m)   OSL_ENSURE(c, m)
84 #else
85 #define TEST_ENSHURE(c, m)   OSL_VERIFY(c)
86 #endif
87 
88 //class IntroTestWritelnOutput;
89 
90 
91 
92 //**************************************************************
93 //*** Hilfs-Funktion, um vom Type eine XIdlClass zu bekommen ***
94 //**************************************************************
95 Reference<XIdlClass> TypeToIdlClass( const Type& rType, const Reference< XMultiServiceFactory > & xMgr )
96 {
97     static Reference< XIdlReflection > xRefl;
98 
99     // void als Default-Klasse eintragen
100     Reference<XIdlClass> xRetClass;
101     typelib_TypeDescription * pTD = 0;
102     rType.getDescription( &pTD );
103     if( pTD )
104     {
105         OUString sOWName( pTD->pTypeName );
106         if( !xRefl.is() )
107         {
108             xRefl = Reference< XIdlReflection >( xMgr->createInstance(
109                 OUString::createFromAscii("com.sun.star.reflection.CoreReflection") ), UNO_QUERY );
110             OSL_ENSURE( xRefl.is(), "### no corereflection!" );
111         }
112         xRetClass = xRefl->forName( sOWName );
113     }
114     return xRetClass;
115 }
116 
117 
118 //****************************************************
119 //*** Hilfs-Funktion, um Any als UString auszugeben ***
120 //****************************************************
121 // ACHTUNG: Kann mal an eine zentrale Stelle uebernommen werden
122 // Wird zunaechst nur fuer einfache Datentypen ausgefuehrt
123 
124 OUString AnyToString( const Any& aValue, sal_Bool bIncludeType, const Reference< XMultiServiceFactory > & xMgr )
125 {
126     Type aValType = aValue.getValueType();
127     TypeClass eType = aValType.getTypeClass();
128     char pBuffer[50];
129 
130     OUString aRetStr;
131     switch( eType )
132     {
133         case TypeClass_TYPE:            aRetStr = OUString::createFromAscii("TYPE TYPE");               break;
134         case TypeClass_INTERFACE:       aRetStr = OUString::createFromAscii("TYPE INTERFACE");      break;
135         case TypeClass_SERVICE:         aRetStr = OUString::createFromAscii("TYPE SERVICE");            break;
136         case TypeClass_STRUCT:          aRetStr = OUString::createFromAscii("TYPE STRUCT");         break;
137         case TypeClass_TYPEDEF:         aRetStr = OUString::createFromAscii("TYPE TYPEDEF");            break;
138         case TypeClass_UNION:           aRetStr = OUString::createFromAscii("TYPE UNION");          break;
139         case TypeClass_ENUM:            aRetStr = OUString::createFromAscii("TYPE ENUM");               break;
140         case TypeClass_EXCEPTION:       aRetStr = OUString::createFromAscii("TYPE EXCEPTION");      break;
141         case TypeClass_ARRAY:           aRetStr = OUString::createFromAscii("TYPE ARRAY");          break;
142         case TypeClass_SEQUENCE:        aRetStr = OUString::createFromAscii("TYPE SEQUENCE");           break;
143         case TypeClass_VOID:            aRetStr = OUString::createFromAscii("TYPE void");               break;
144         case TypeClass_ANY:             aRetStr = OUString::createFromAscii("TYPE any");                break;
145         case TypeClass_UNKNOWN:         aRetStr = OUString::createFromAscii("TYPE unknown");            break;
146         case TypeClass_BOOLEAN:
147         {
148             sal_Bool b = *(sal_Bool*)aValue.getValue();
149             //aRet.setValue( &b, getCppuBooleanType() );
150             //aValue >>= b;
151             aRetStr = OUString::valueOf( b );
152             break;
153         }
154         case TypeClass_CHAR:
155         {
156             sal_Unicode c = *(sal_Unicode*)aValue.getValue();
157             //aValue >>= c;
158             //getCppuCharType()
159             aRetStr = OUString::valueOf( c );
160             break;
161         }
162         case TypeClass_STRING:
163         {
164             aValue >>= aRetStr;
165             break;
166         }
167         case TypeClass_FLOAT:
168         {
169             float f(0.0);
170             aValue >>= f;
171             snprintf( pBuffer, sizeof( pBuffer ), "%f", f );
172             aRetStr = OUString( pBuffer, strlen( pBuffer ), RTL_TEXTENCODING_ASCII_US );
173             break;
174         }
175         case TypeClass_DOUBLE:
176         {
177             double d(0.0);
178             aValue >>= d;
179             snprintf( pBuffer, sizeof( pBuffer ), "%f", d );
180             aRetStr = OUString( pBuffer, strlen( pBuffer ), RTL_TEXTENCODING_ASCII_US );
181             break;
182         }
183         case TypeClass_BYTE:
184         {
185             sal_Int8 n(0);
186             aValue >>= n;
187             aRetStr = OUString::valueOf( (sal_Int32) n );
188             break;
189         }
190         case TypeClass_SHORT:
191         {
192             sal_Int16 n(0);
193             aValue >>= n;
194             aRetStr = OUString::valueOf( (sal_Int32) n );
195             break;
196         }
197         case TypeClass_LONG:
198         {
199             sal_Int32 n(0);
200             aValue >>= n;
201             aRetStr = OUString::valueOf( n );
202             break;
203         }
204         /*
205         case TypeClass_HYPER:
206         {
207             aRetStr = L"TYPE HYPER";
208             break;
209         }
210         case TypeClass_UNSIGNED_SHORT:
211         {
212             aRetStr = StringToUString(WSString(aValue.getUINT16()), CHARSET_SYSTEM);
213             break;
214         }
215         case TypeClass_UNSIGNED_LONG:
216         {
217             aRetStr = StringToUString(WSString(aValue.getUINT32()), CHARSET_SYSTEM);
218             break;
219         }
220         case TypeClass_UNSIGNED_HYPER:
221         {
222             aRetStr = L"TYPE UNSIGNED_HYPER";
223             break;
224         }
225         */
226     default: ;
227     }
228 
229     if( bIncludeType )
230     {
231         Reference< XIdlClass > xIdlClass = TypeToIdlClass( aValType, xMgr );
232         aRetStr = aRetStr + OUString( OUString::createFromAscii(" (Typ: ") ) + xIdlClass->getName() + OUString::createFromAscii(")");
233     }
234     return aRetStr;
235 }
236 
237 /*
238 // Hilfs-Funktion, um ein UString in einen Any zu konvertieren
239 UsrAny StringToAny( UString aStr, TypeClass eTargetType )
240 {
241     UsrAny aRetAny;
242     switch( eTargetType )
243     {
244         case TypeClass_INTERFACE:       break;
245         case TypeClass_SERVICE:         break;
246         case TypeClass_STRUCT:          break;
247         case TypeClass_TYPEDEF:         break;
248         case TypeClass_UNION:           break;
249         case TypeClass_ENUM:            break;
250         case TypeClass_EXCEPTION:       break;
251         case TypeClass_ARRAY:           break;
252         case TypeClass_SEQUENCE:        break;
253         case TypeClass_VOID:            break;
254         case TypeClass_ANY:             break;
255         case TypeClass_UNKNOWN:         break;
256         case TypeClass_BOOLEAN:         aRetAny.setBOOL( short(aStr)!=0 );  break;
257         case TypeClass_CHAR:            aRetAny.setChar( char(aStr) );      break;
258         case TypeClass_STRING:          aRetAny.setString( aStr );          break;
259         case TypeClass_FLOAT:           aRetAny.setFloat( (float)strtod( aStr.GetStr(), NULL ) );   break;
260         case TypeClass_DOUBLE:          aRetAny.setDouble( strtod( aStr.GetStr(), NULL ) ); break;
261         case TypeClass_BYTE:            aRetAny.setBYTE( BYTE(short(aStr)) );   break;
262         case TypeClass_SHORT:           aRetAny.setINT16( short(aStr) );    break;
263         case TypeClass_LONG:            aRetAny.setINT32( long(aStr) );     break;
264         case TypeClass_HYPER:           break;
265         case TypeClass_UNSIGNED_SHORT:  aRetAny.setUINT16( USHORT(aStr) );  break;
266         case TypeClass_UNSIGNED_LONG:   aRetAny.setUINT32( ULONG(aStr) );   break;
267         case TypeClass_UNSIGNED_HYPER:  break;
268     }
269     return aRetAny;
270 }
271 */
272 
273 
274 //*****************************************
275 //*** XPropertySetInfo fuer Test-Klasse ***
276 //*****************************************
277 
278 class ImplPropertySetInfo : public ImplPropertySetInfoHelper
279 {
280     friend class ImplIntroTest;
281 
282     Reference< XMultiServiceFactory > mxMgr;
283 
284 public:
285     ImplPropertySetInfo( const Reference< XMultiServiceFactory > & xMgr )
286         : mxMgr( xMgr ) {}
287         //: mxMgr( xMgr ), ImplPropertySetInfoHelper( xMgr ) {}
288 
289 /*
290     // Methoden von XInterface
291     virtual sal_Bool    SAL_CALL queryInterface( const Uik & rUik, Any & ifc ) throw( RuntimeException );
292     virtual void        SAL_CALL acquire() throw() { OWeakObject::acquire(); }
293     virtual void        SAL_CALL release() throw() { OWeakObject::release(); }
294     //ALT: sal_Bool queryInterface( Uik aUik, Reference<XInterface> & rOut );
295 */
296 
297     // Methods of XPropertySetInfo
298     virtual Sequence< Property > SAL_CALL getProperties(  )
299         throw(RuntimeException);
300     virtual Property SAL_CALL getPropertyByName( const OUString& aName )
301         throw(UnknownPropertyException, RuntimeException);
302     virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
303         throw(RuntimeException);
304     //virtual Sequence< Property > SAL_CALL getProperties(void) throw( RuntimeException );
305     //virtual Property SAL_CALL getPropertyByName(const OUString& Name) throw( RuntimeException );
306     //virtual sal_Bool SAL_CALL hasPropertyByName(const OUString& Name) throw( RuntimeException );
307 };
308 
309 
310 /*
311 // Methoden von XInterface
312 sal_Bool SAL_CALL ImplPropertySetInfo::queryInterface( const Uik & rUik, Any & ifc )
313     throw( RuntimeException )
314 {
315     // PropertySet-Implementation
316     if( com::sun::star::uno::queryInterface( rUik, ifc,
317                                              SAL_STATIC_CAST(XPropertySetInfo*, this) ) )
318         return sal_True;
319 
320     return OWeakObject::queryInterface( rUik, ifc );
321 }
322 
323 sal_Bool ImplPropertySetInfo::queryInterface( Uik aUik, Reference<XInterface> & rOut )
324 {
325     if( aUik == XPropertySetInfo::getSmartUik() )
326         rOut = (XPropertySetInfo *)this;
327     else
328         UsrObject::queryInterface( aUik, rOut );
329     return rOut.is();
330 }
331 */
332 
333 Sequence< Property > ImplPropertySetInfo::getProperties(void)
334     throw( RuntimeException )
335 {
336     static Sequence<Property> * pSeq = NULL;
337 
338     if( !pSeq )
339     {
340         // die Informationen f�r die Properties "Width", "Height" und "Name" anlegen
341         pSeq = new Sequence<Property>( 3 );
342         Property * pAry = pSeq->getArray();
343 
344         pAry[0].Name = OUString::createFromAscii("Factor");
345         pAry[0].Handle = -1;
346         pAry[0].Type = getCppuType( (double*) NULL );
347         //pAry[0].Type = TypeToIdlClass( getCppuType( (double*) NULL ), mxMgr );
348         //pAry[0].Type = Double_getReflection()->getIdlClass();
349         pAry[0].Attributes = BOUND | TRANSIENT;
350 
351         pAry[1].Name = OUString::createFromAscii("MyCount");
352         pAry[1].Handle = -1;
353         pAry[1].Type = getCppuType( (sal_Int32*) NULL );
354         //pAry[1].Type = TypeToIdlClass( getCppuType( (sal_Int32*) NULL ), mxMgr );
355         //pAry[1].Type = INT32_getReflection()->getIdlClass();
356         pAry[1].Attributes = BOUND | TRANSIENT;
357 
358         pAry[2].Name = OUString::createFromAscii("Info");
359         pAry[2].Handle = -1;
360         pAry[2].Type = getCppuType( (OUString*) NULL );
361         //pAry[2].Type = TypeToIdlClass( getCppuType( (OUString*) NULL ), mxMgr );
362         //pAry[2].Type = OUString_getReflection()->getIdlClass();
363         pAry[2].Attributes = TRANSIENT;
364     }
365     // Die Information �ber alle drei Properties liefern.
366     return *pSeq;
367 }
368 
369 Property ImplPropertySetInfo::getPropertyByName(const OUString& Name)
370     throw( UnknownPropertyException, RuntimeException )
371 {
372     Sequence<Property> aSeq = getProperties();
373     const Property * pAry = aSeq.getConstArray();
374 
375     for( sal_Int32 i = aSeq.getLength(); i--; )
376     {
377         if( pAry[i].Name == Name )
378             return pAry[i];
379     }
380     // Property unbekannt, also leere liefern
381     return Property();
382 }
383 
384 sal_Bool ImplPropertySetInfo::hasPropertyByName(const OUString& Name)
385     throw( RuntimeException )
386 {
387     Sequence<Property> aSeq = getProperties();
388     const Property * pAry = aSeq.getConstArray();
389 
390     for( sal_Int32 i = aSeq.getLength(); i--; )
391     {
392         if( pAry[i].Name == Name )
393             return sal_True;
394     }
395     // Property unbekannt, also leere liefern
396     return sal_False;
397 }
398 
399 
400 
401 
402 //*****************************************************************
403 
404 
405 
406 class ImplIntroTest : public ImplIntroTestHelper
407 {
408     Reference< XMultiServiceFactory > mxMgr;
409 
410     friend class ImplPropertySetInfo;
411 
412     // Properties fuer das PropertySet
413     Any aAnyArray[10];
414 
415     // Optionale Schnittstelle fuer die writeln-Ausgabe
416     //IntroTestWritelnOutput* m_pOutput;
417 
418     Reference< XPropertySetInfo > m_xMyInfo;
419 
420     OUString m_ObjectName;
421 
422     sal_Int16 m_nMarkusAge;
423     sal_Int16 m_nMarkusChildrenCount;
424 
425     long m_lDroenk;
426     sal_Int16 m_nBla;
427     sal_Int16 m_nBlub;
428     sal_Int16 m_nGulp;
429     sal_Int16 m_nLaber;
430     TypeClass eTypeClass;
431     Sequence< OUString > aStringSeq;
432     Sequence< Sequence< Sequence< sal_Int16 > > > aMultSeq;
433     Reference< XIntroTest > m_xIntroTest;
434 
435     // Daten fuer NameAccess
436     Reference< XIntroTest >* pNameAccessTab;
437 
438     // Daten fuer IndexAccess
439     Reference< XIntroTest >* pIndexAccessTab;
440     sal_Int16 iIndexAccessCount;
441 
442     // struct-Properties
443     Property m_aFirstStruct;
444     PropertyValue m_aSecondStruct;
445 
446     // Listener merken (zunaechst einfach, nur einen pro Property)
447     Reference< XPropertyChangeListener > aPropChangeListener;
448     OUString aPropChangeListenerStr;
449     Reference< XVetoableChangeListener > aVetoPropChangeListener;
450     OUString aVetoPropChangeListenerStr;
451 
452     void Init( void );
453 
454 public:
455     ImplIntroTest( const Reference< XMultiServiceFactory > & xMgr )
456         : mxMgr( xMgr )
457         //: mxMgr( xMgr ), ImplIntroTestHelper( xMgr )
458     {
459         Init();
460     }
461 
462     /*
463     ImplIntroTest( IntroTestWritelnOutput* pOutput_ )
464     {
465         Init();
466         m_pOutput = pOutput_;
467     }
468     */
469 
470     //SMART_UNO_DECLARATION(ImplIntroTest,UsrObject);
471 
472     //BOOL queryInterface( Uik aUik, Reference< XInterface > & rOut );
473     //Reference< XIdlClass > getIdlClass();
474 
475     // Trotz virtual inline, um Schreibarbeit zu sparen (nur fuer Testzwecke)
476     // XPropertySet
477     virtual Reference< XPropertySetInfo > SAL_CALL getPropertySetInfo(  )
478         throw(RuntimeException);
479     virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const Any& aValue )
480         throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException);
481     virtual Any SAL_CALL getPropertyValue( const OUString& PropertyName )
482         throw(UnknownPropertyException, WrappedTargetException, RuntimeException);
483     virtual void SAL_CALL addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ )
484         throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
485             {}
486     virtual void SAL_CALL removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ )
487         throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
488             {}
489     virtual void SAL_CALL addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ )
490         throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
491             {}
492     virtual void SAL_CALL removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ )
493         throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
494             {}
495 
496     /*
497     virtual void setIndexedPropertyValue(const OUString& aPropertyName, INT32 nIndex, const Any& aValue) {}
498     virtual Any getIndexedPropertyValue(const UString& aPropertyName, INT32 nIndex) const { return Any(); }
499     virtual void addPropertyChangeListener(const UString& aPropertyName, const XPropertyChangeListenerRef& aListener)
500         THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
501     virtual void removePropertyChangeListener(const UString& aPropertyName, const XPropertyChangeListenerRef& aListener)
502         THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
503     virtual void addVetoableChangeListener(const UString& aPropertyName, const XVetoableChangeListenerRef& aListener)
504         THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
505     virtual void removeVetoableChangeListener(const UString& aPropertyName, const XVetoableChangeListenerRef& aListener)
506         THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
507         */
508 
509     // XIntroTest-Methoden
510     // Attributes
511     virtual OUString SAL_CALL getObjectName() throw(RuntimeException)
512         { return m_ObjectName; }
513     virtual void SAL_CALL setObjectName( const OUString& _objectname ) throw(RuntimeException)
514         { m_ObjectName = _objectname; }
515     virtual OUString SAL_CALL getFirstName()
516         throw(RuntimeException);
517     virtual OUString SAL_CALL getLastName() throw(RuntimeException)
518         { return OUString( OUString::createFromAscii("Meyer") ); }
519     virtual sal_Int16 SAL_CALL getAge() throw(RuntimeException)
520         { return m_nMarkusAge; }
521     virtual sal_Int16 SAL_CALL getChildrenCount() throw(RuntimeException)
522         { return m_nMarkusChildrenCount; }
523     virtual void SAL_CALL setChildrenCount( sal_Int16 _childrencount ) throw(RuntimeException)
524         { m_nMarkusChildrenCount = _childrencount; }
525     virtual Property SAL_CALL getFirstStruct() throw(RuntimeException)
526         { return m_aFirstStruct; }
527     virtual void SAL_CALL setFirstStruct( const Property& _firststruct ) throw(RuntimeException)
528         { m_aFirstStruct = _firststruct; }
529     virtual PropertyValue SAL_CALL getSecondStruct() throw(RuntimeException)
530         { return m_aSecondStruct; }
531     virtual void SAL_CALL setSecondStruct( const PropertyValue& _secondstruct ) throw(RuntimeException)
532         { m_aSecondStruct = _secondstruct; }
533 
534     // Methods
535     virtual void SAL_CALL writeln( const OUString& Text )
536         throw(RuntimeException);
537     virtual sal_Int32 SAL_CALL getDroenk(  ) throw(RuntimeException)
538         { return m_lDroenk; }
539     virtual Reference< ::ModuleA::XIntroTest > SAL_CALL getIntroTest(  ) throw(RuntimeException);
540     virtual sal_Int32 SAL_CALL getUps( sal_Int32 l ) throw(RuntimeException)
541         { return 2*l; }
542     virtual void SAL_CALL setDroenk( sal_Int32 l ) throw(RuntimeException)
543         { m_lDroenk = l; }
544     virtual sal_Int16 SAL_CALL getBla(  ) throw(RuntimeException)
545         { return m_nBla; }
546     virtual void SAL_CALL setBla( sal_Int32 n ) throw(RuntimeException)
547         { m_nBla = (sal_Int16)n; }
548     virtual sal_Int16 SAL_CALL getBlub(  ) throw(RuntimeException)
549         { return m_nBlub; }
550     virtual void SAL_CALL setBlub( sal_Int16 n ) throw(RuntimeException)
551         { m_nBlub = n; }
552     virtual sal_Int16 SAL_CALL getGulp(  ) throw(RuntimeException)
553         { return m_nGulp; }
554     virtual sal_Int16 SAL_CALL setGulp( sal_Int16 n ) throw(RuntimeException)
555         { m_nGulp = n; return 1; }
556     virtual TypeClass SAL_CALL getTypeClass( sal_Int16 /*n*/ ) throw(RuntimeException)
557         { return eTypeClass; }
558     virtual void SAL_CALL setTypeClass( TypeClass t, double /*d1*/, double /*d2*/ ) throw(RuntimeException)
559         { eTypeClass = t; }
560     virtual Sequence< OUString > SAL_CALL getStrings(  ) throw(RuntimeException)
561         { return aStringSeq; }
562     virtual void SAL_CALL setStrings( const Sequence< OUString >& Strings ) throw(RuntimeException)
563         { aStringSeq = Strings; }
564     virtual void SAL_CALL setStringsPerMethod( const Sequence< OUString >& Strings, sal_Int16 /*n*/ ) throw(RuntimeException)
565         { aStringSeq = Strings; }
566     virtual Sequence< Sequence< Sequence< sal_Int16 > > > SAL_CALL getMultiSequence(  ) throw(RuntimeException)
567         { return aMultSeq; }
568     virtual void SAL_CALL setMultiSequence( const Sequence< Sequence< Sequence< sal_Int16 > > >& Seq ) throw(RuntimeException)
569         { aMultSeq = Seq; }
570     virtual void SAL_CALL addPropertiesChangeListener( const Sequence< OUString >& PropertyNames, const Reference< XPropertiesChangeListener >& Listener )
571         throw(RuntimeException);
572     virtual void SAL_CALL removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& Listener )
573         throw(RuntimeException);
574 
575 
576     // Methods of XElementAccess
577     virtual Type SAL_CALL getElementType(  )
578         throw(RuntimeException);
579     virtual sal_Bool SAL_CALL hasElements(  )
580         throw(RuntimeException);
581     //virtual XIdlClassRef getElementType(void) constTHROWS( (UsrSystemException) );
582     //virtual BOOL hasElements(void) const THROWS( (UsrSystemException) );
583 
584     // XNameAccess-Methoden
585     // Methods
586     virtual Any SAL_CALL getByName( const OUString& aName )
587         throw(NoSuchElementException, WrappedTargetException, RuntimeException);
588     virtual Sequence< OUString > SAL_CALL getElementNames(  )
589         throw(RuntimeException);
590     virtual sal_Bool SAL_CALL hasByName( const OUString& aName )
591         throw(RuntimeException);
592     //virtual Any getByName(const UString& Name) const
593         //THROWS( (NoSuchElementException, WrappedTargetException, UsrSystemException) );
594     //virtual Sequence<UString> getElementNames(void) const THROWS( (UsrSystemException) );
595     //virtual BOOL hasByName(const UString& Name) const THROWS( (UsrSystemException) );
596 
597     // XIndexAccess-Methoden
598     // Methods
599     virtual sal_Int32 SAL_CALL getCount(  )
600         throw(RuntimeException);
601     virtual Any SAL_CALL getByIndex( sal_Int32 Index )
602         throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
603     //virtual INT32 getCount(void) const THROWS( (UsrSystemException) );
604     //virtual Any getByIndex(INT32 Index) const
605         //THROWS( (IndexOutOfBoundsException, WrappedTargetException, UsrSystemException) );
606 };
607 
608 //SMART_UNO_IMPLEMENTATION(ImplIntroTest,UsrObject)
609 
610 void ImplIntroTest::Init( void )
611 {
612     // Eindeutigen Namen verpassen
613     static sal_Int32 nObjCount = 0;
614     OUString aName( OUString::createFromAscii("IntroTest-Obj Nr. ") );
615     aName += OUString::valueOf( nObjCount );
616     setObjectName( aName );
617 
618     // Properties initialisieren
619     aAnyArray[0] <<= 3.14;
620     aAnyArray[1] <<= (sal_Int32)42;
621     aAnyArray[2] <<= OUString( OUString::createFromAscii("Hallo") );
622 
623     // Output-Interface
624     //m_pOutput = NULL;
625 
626     // Einmal fuer den internen Gebrauch die PropertySetInfo abholen
627     m_xMyInfo = getPropertySetInfo();
628     m_xMyInfo->acquire();       // sonst raucht es am Programm-Ende ab
629 
630     m_nMarkusAge = 33;
631     m_nMarkusChildrenCount = 2;
632 
633     m_lDroenk = 314;
634     m_nBla = 42;
635     m_nBlub = 111;
636     m_nGulp = 99;
637     m_nLaber = 1;
638     eTypeClass = TypeClass_INTERFACE;
639 
640     // String-Sequence intitialisieren
641     aStringSeq.realloc( 3 );
642     OUString* pStr = aStringSeq.getArray();
643     pStr[ 0 ] = OUString( OUString::createFromAscii("String 0") );
644     pStr[ 1 ] = OUString( OUString::createFromAscii("String 1") );
645     pStr[ 2 ] = OUString( OUString::createFromAscii("String 2") );
646 
647     // structs initialisieren
648     m_aFirstStruct.Name = OUString::createFromAscii("FirstStruct-Name");
649     m_aFirstStruct.Handle = 77777;
650     //XIdlClassRef Type;
651     m_aFirstStruct.Attributes = -222;
652 
653     //XInterfaceRef Source;
654     Any Value;
655     Value <<= 2.718281828459;
656     m_aSecondStruct.Value = Value;
657     //XIdlClassRef ListenerType;
658     m_aSecondStruct.State = PropertyState_DIRECT_VALUE;
659 
660     // IndexAccess
661     iIndexAccessCount = DEFAULT_INDEX_ACCESS_COUNT;
662     pIndexAccessTab = NULL;
663     pNameAccessTab = NULL;
664 }
665 
666 /*
667 BOOL ImplIntroTest::queryInterface( Uik aUik, XInterfaceRef & rOut )
668 {
669     if( aUik == XIntroTest::getSmartUik() )
670         rOut = (XIntroTest*)this;
671     else if( aUik == XPropertySet::getSmartUik() )
672         rOut = (XPropertySet*)this;
673     else if( aUik == XNameAccess::getSmartUik() )
674         rOut = (XNameAccess*)this;
675     else if( aUik == XIndexAccess::getSmartUik() )
676         rOut = (XIndexAccess*)this;
677     else if( aUik == ((XElementAccess*)NULL)->getSmartUik() )
678         rOut = (XElementAccess*)(XIndexAccess *)this;
679     else
680         UsrObject::queryInterface( aUik, rOut );
681     return rOut.is();
682 }
683 
684 XIdlClassRef ImplIntroTest::getIdlClass()
685 {
686     static XIdlClassRef xClass = createStandardClass( L"ImplIntroTest",
687         UsrObject::getUsrObjectIdlClass(), 4,
688             XIntroTest_getReflection(),
689             XPropertySet_getReflection(),
690             XNameAccess_getReflection(),
691             XIndexAccess_getReflection() );
692     return xClass;
693 }
694 */
695 
696 Reference< XPropertySetInfo > ImplIntroTest::getPropertySetInfo()
697     throw(RuntimeException)
698 {
699     static ImplPropertySetInfo aInfo( mxMgr );
700     // Alle Objekt haben die gleichen Properties, deshalb kann
701     // die Info f�r alle gleich sein
702     return &aInfo;
703 
704     //if( m_xMyInfo == NULL )
705     //  ((ImplIntroTest*)this)->m_xMyInfo = new ImplPropertySetInfo( this );
706     //return m_xMyInfo;
707 }
708 
709 void ImplIntroTest::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
710     throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
711 //void ImplIntroTest::setPropertyValue( const UString& aPropertyName, const Any& aValue )
712 //  THROWS( (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, UsrSystemException) )
713 {
714     if( aPropChangeListener.is() && aPropertyName == aPropChangeListenerStr )
715     {
716         PropertyChangeEvent aEvt;
717         aEvt.Source = (OWeakObject*)this;
718         aEvt.PropertyName = aPropertyName;
719         aEvt.PropertyHandle = 0L;
720         //aEvt.OldValue;
721         //aEvt.NewValue;
722         //aEvt.PropagationId;
723         aPropChangeListener->propertyChange( aEvt );
724     }
725     if( aVetoPropChangeListener.is() && aPropertyName == aVetoPropChangeListenerStr )
726     {
727         PropertyChangeEvent aEvt;
728         aEvt.Source = (OWeakObject*)this;
729         aEvt.PropertyName = aVetoPropChangeListenerStr;
730         aEvt.PropertyHandle = 0L;
731         //aEvt.OldValue;
732         //aEvt.NewValue;
733         //aEvt.PropagationId;
734         aVetoPropChangeListener->vetoableChange( aEvt );
735     }
736 
737     Sequence<Property> aPropSeq = m_xMyInfo->getProperties();
738     sal_Int32 nLen = aPropSeq.getLength();
739     for( sal_Int32 i = 0 ; i < nLen ; i++ )
740     {
741         Property aProp = aPropSeq.getArray()[ i ];
742         if( aProp.Name == aPropertyName )
743             aAnyArray[i] = aValue;
744     }
745 }
746 
747 Any ImplIntroTest::getPropertyValue( const OUString& PropertyName )
748     throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
749 //Any ImplIntroTest::getPropertyValue(const UString& aPropertyName) const
750     //THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) )
751 {
752     Sequence<Property> aPropSeq = m_xMyInfo->getProperties();
753     sal_Int32 nLen = aPropSeq.getLength();
754     for( sal_Int32 i = 0 ; i < nLen ; i++ )
755     {
756         Property aProp = aPropSeq.getArray()[ i ];
757         if( aProp.Name == PropertyName )
758             return aAnyArray[i];
759     }
760     return Any();
761 }
762 
763 OUString ImplIntroTest::getFirstName(void)
764     throw(RuntimeException)
765 {
766     return OUString( OUString::createFromAscii("Markus") );
767 }
768 
769 void ImplIntroTest::writeln( const OUString& Text )
770     throw(RuntimeException)
771 {
772     OString aStr( Text.getStr(), Text.getLength(), RTL_TEXTENCODING_ASCII_US );
773 
774     // Haben wir ein Output?
775     //if( m_pOutput )
776     //{
777         //m_pOutput->doWriteln( TextStr );
778     //}
779     // Sonst einfach rausbraten
780     //else
781     {
782         printf( "%s", aStr.getStr() );
783     }
784 }
785 
786 Reference< XIntroTest > ImplIntroTest::getIntroTest()
787     throw(RuntimeException)
788 //XIntroTestRef ImplIntroTest::getIntroTest(void) THROWS( (UsrSystemException) )
789 {
790     if( !m_xIntroTest.is() )
791         m_xIntroTest = new ImplIntroTest( mxMgr );
792     return m_xIntroTest;
793 }
794 
795 // Methoden von XElementAccess
796 Type ImplIntroTest::getElementType(  )
797     throw(RuntimeException)
798 //XIdlClassRef ImplIntroTest::getElementType(void) const THROWS( (UsrSystemException) )
799 {
800     // TODO
801     Type aRetType;
802     return aRetType;
803     //return Reference< XIdlClass >();
804     //return Void_getReflection()->getIdlClass();
805 }
806 
807 sal_Bool ImplIntroTest::hasElements(  )
808     throw(RuntimeException)
809 //BOOL ImplIntroTest::hasElements(void) const THROWS( (UsrSystemException) )
810 {
811     return sal_True;
812 }
813 
814 // XNameAccess-Methoden
815 sal_Int32 getIndexForName( const OUString& ItemName )
816 {
817     OUString aLeftStr = ItemName.copy( 0, 4 );
818     if( aLeftStr == OUString::createFromAscii("Item") )
819     {
820         // TODO
821         OUString aNumStr = ItemName.copy( 4 );
822         //sal_Int32 iIndex = (INT32)UStringToString( aNumStr, CHARSET_SYSTEM );
823         //if( iIndex < DEFAULT_NAME_ACCESS_COUNT )
824             //return iIndex;
825     }
826     return -1;
827 }
828 
829 
830 Any ImplIntroTest::getByName( const OUString& aName )
831     throw(NoSuchElementException, WrappedTargetException, RuntimeException)
832 //Any ImplIntroTest::getByName(const UString& Name) const
833     //THROWS( (NoSuchElementException, WrappedTargetException, UsrSystemException) )
834 {
835     Any aRetAny;
836 
837     if( !pNameAccessTab  )
838         ((ImplIntroTest*)this)->pNameAccessTab  = new Reference< XIntroTest >[ DEFAULT_NAME_ACCESS_COUNT ];
839 
840     sal_Int32 iIndex = getIndexForName( aName );
841     if( iIndex != -1 )
842     {
843         if( !pNameAccessTab[iIndex].is() )
844         {
845             ImplIntroTest* p = new ImplIntroTest( mxMgr );
846             OUString aName2( OUString::createFromAscii("IntroTest by Name-Access, Index = ") );
847             aName2 += OUString::valueOf( iIndex );
848             //aName2 = aName2 + StringToUString( String( iIndex ), CHARSET_SYSTEM );
849             p->setObjectName( aName2 );
850             pNameAccessTab[iIndex] = p;
851         }
852 
853         Reference< XIntroTest > xRet = pNameAccessTab[iIndex];
854         aRetAny = makeAny( xRet );
855 
856         //aRetAny.set( &xRet, XIntroTest_getReflection() );
857         //return (UsrObject*)(XIntroTest*)pNameAccessTab[iIndex];
858     }
859     return aRetAny;
860 }
861 
862 Sequence< OUString > ImplIntroTest::getElementNames(  )
863     throw(RuntimeException)
864 //Sequence<UString> ImplIntroTest::getElementNames(void) const THROWS( (UsrSystemException) )
865 {
866     Sequence<OUString> aStrSeq( DEFAULT_NAME_ACCESS_COUNT );
867     OUString* pStr = aStrSeq.getArray();
868     for( sal_Int32 i = 0 ; i < DEFAULT_NAME_ACCESS_COUNT ; i++ )
869     {
870         OUString aName( OUString::createFromAscii("Item") );
871         aName += OUString::valueOf( i );
872         //aName = aName + StringToUString( i, CHARSET_SYSTEM );
873         pStr[i] = aName;
874     }
875     return aStrSeq;
876 }
877 
878 sal_Bool ImplIntroTest::hasByName( const OUString& aName )
879     throw(RuntimeException)
880 //BOOL ImplIntroTest::hasByName(const UString& Name) const THROWS( (UsrSystemException) )
881 {
882     return ( getIndexForName( aName ) != -1 );
883 }
884 
885 // XIndexAccess-Methoden
886 sal_Int32 ImplIntroTest::getCount(  )
887     throw(RuntimeException)
888 //sal_Int32 ImplIntroTest::getCount(void) const THROWS( (UsrSystemException) )
889 {
890     return iIndexAccessCount;
891 }
892 
893 Any ImplIntroTest::getByIndex( sal_Int32 Index )
894     throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
895 //Any ImplIntroTest::getByIndex( sal_Int32 Index ) const
896     //THROWS( (IndexOutOfBoundsException, WrappedTargetException, UsrSystemException) )
897 {
898     Any aRetAny;
899 
900     if( !pIndexAccessTab )
901         ((ImplIntroTest*)this)->pIndexAccessTab = new Reference< XIntroTest >[ iIndexAccessCount ];
902 
903     if( Index < iIndexAccessCount )
904     {
905         if( !pNameAccessTab[Index].is() )
906         {
907             ImplIntroTest* p = new ImplIntroTest( mxMgr );
908             OUString aName( OUString::createFromAscii("IntroTest by Index-Access, Index = ") );
909             aName += OUString::valueOf( Index );
910             //aName = aName + StringToUString( String( iIndex ), CHARSET_SYSTEM );
911             p->setObjectName( aName );
912             pIndexAccessTab[Index] = p;
913         }
914         Reference< XIntroTest > xRet = pIndexAccessTab[Index];
915         aRetAny = makeAny( xRet );
916     }
917     return aRetAny;
918 }
919 
920 void ImplIntroTest::addPropertiesChangeListener( const Sequence< OUString >& /*PropertyNames*/,
921                                                  const Reference< XPropertiesChangeListener >& /*Listener*/ )
922         throw(RuntimeException)
923 //void ImplIntroTest::addPropertiesChangeListener
924 //(const Sequence< UString >& PropertyNames, const XPropertiesChangeListenerRef& Listener)
925     //THROWS( (UsrSystemException) )
926 {
927 }
928 
929 void ImplIntroTest::removePropertiesChangeListener
930 ( const Reference< XPropertiesChangeListener >& /*Listener*/ )
931         throw(RuntimeException)
932 //void ImplIntroTest::removePropertiesChangeListener(const XPropertiesChangeListenerRef& Listener)
933     //THROWS( (UsrSystemException) )
934 {
935 }
936 
937 
938 
939 struct DefItem
940 {
941     char const * pName;
942     sal_Int32 nConcept;
943 };
944 
945 // Spezial-Wert fuer Method-Concept, um "normale" Funktionen kennzeichnen zu koennen
946 #define  MethodConcept_NORMAL_IMPL      0x80000000
947 
948 
949 // Test-Objekt liefern
950 Any getIntrospectionTestObject( const Reference< XMultiServiceFactory > & xMgr )
951 {
952     Any aObjAny;
953     Reference< XIntroTest > xTestObj = new ImplIntroTest( xMgr );
954     aObjAny.setValue( &xTestObj, ::getCppuType( (const Reference< XIntroTest > *)0 ) );
955     return aObjAny;
956 }
957 
958 static sal_Bool test_introsp( Reference< XMultiServiceFactory > xMgr,
959                               Reference< XIdlReflection > /*xRefl*/, Reference< XIntrospection > xIntrospection )
960 {
961     DefItem pPropertyDefs[] =
962     {
963         { "Factor", PropertyConcept::PROPERTYSET },
964         { "MyCount", PropertyConcept::PROPERTYSET },
965         { "Info", PropertyConcept::PROPERTYSET },
966         { "ObjectName", PropertyConcept::ATTRIBUTES },
967         { "FirstName", PropertyConcept::ATTRIBUTES },
968         { "LastName", PropertyConcept::ATTRIBUTES },
969         { "Age", PropertyConcept::ATTRIBUTES },
970         { "ChildrenCount", PropertyConcept::ATTRIBUTES },
971         { "FirstStruct", PropertyConcept::ATTRIBUTES },
972         { "SecondStruct", PropertyConcept::ATTRIBUTES },
973         { "Droenk", PropertyConcept::METHODS },
974         { "IntroTest", PropertyConcept::METHODS },
975         { "Bla", PropertyConcept::METHODS },
976         { "Blub", PropertyConcept::METHODS },
977         { "Gulp", PropertyConcept::METHODS },
978         { "Strings", PropertyConcept::METHODS },
979         { "MultiSequence", PropertyConcept::METHODS },
980         { "PropertySetInfo", PropertyConcept::METHODS },
981         { "ElementType", PropertyConcept::METHODS },
982         { "ElementNames", PropertyConcept::METHODS },
983         { "Count", PropertyConcept::METHODS },
984         { "Types", PropertyConcept::METHODS },
985         { "ImplementationId", PropertyConcept::METHODS },
986         { NULL, 0 }
987     };
988 
989     // Tabelle der Property-Namen, die gefunden werden muessen
990 //  char* pDemandedPropNames[] =
991 //  {
992 //      "Factor",
993 //      "MyCount",
994 //      "Info",
995 //      "ObjectName",
996 //      "FirstName",
997 //      "LastName",
998 //      "Age",
999 //      "ChildrenCount",
1000 //      "FirstStruct",
1001 //      "SecondStruct",
1002 //      "Droenk",
1003 //      "IntroTest",
1004 //      "Bla",
1005 //      "Blub",
1006 //      "Gulp",
1007 //      "Strings",
1008 //      "MultiSequence",
1009 //      "PropertySetInfo",
1010 //      "ElementType",
1011 //      "ElementNames",
1012 //      "Count",
1013 //      "Types"
1014 //      "ImplementationId"
1015 //  };
1016 
1017     char const * pDemandedPropVals[] =
1018     {
1019         "3.140000",
1020         "42",
1021         "Hallo",
1022         "IntroTest-Obj Nr. 0",
1023         "Markus",
1024         "Meyer",
1025         "33",
1026         "2",
1027         "TYPE STRUCT",
1028         "TYPE STRUCT",
1029         "314",
1030         "TYPE INTERFACE",
1031         "42",
1032         "111",
1033         "99",
1034         "TYPE SEQUENCE",
1035         "TYPE SEQUENCE",
1036         "TYPE INTERFACE",
1037         "TYPE TYPE",
1038         "TYPE SEQUENCE",
1039         "10",
1040         "TYPE SEQUENCE",
1041         "TYPE SEQUENCE",
1042     };
1043 
1044     char const * pDemandedModifiedPropVals[] =
1045     {
1046         "4.140000",
1047         "43",
1048         "Hallo (Modified!)",
1049         "IntroTest-Obj Nr. 0 (Modified!)",
1050         "Markus",
1051         "Meyer",
1052         "33",
1053         "3",
1054         "Wert wurde nicht modifiziert",
1055         "Wert wurde nicht modifiziert",
1056         "315",
1057         "Wert wurde nicht modifiziert",
1058         "42",
1059         "112",
1060         "99",
1061         "Wert wurde nicht modifiziert",
1062         "Wert wurde nicht modifiziert",
1063         "Wert wurde nicht modifiziert",
1064         "Wert wurde nicht modifiziert",
1065         "Wert wurde nicht modifiziert",
1066         "10",
1067         "Wert wurde nicht modifiziert"
1068         "Wert wurde nicht modifiziert"
1069     };
1070 
1071     char const * pDemandedPropTypes[] =
1072     {
1073         "double",
1074         "long",
1075         "string",
1076         "string",
1077         "string",
1078         "string",
1079         "short",
1080         "short",
1081         "com.sun.star.beans.Property",
1082         "com.sun.star.beans.PropertyValue",
1083         "long",
1084         "ModuleA.XIntroTest",
1085         "short",
1086         "short",
1087         "short",
1088         "[]string",
1089         "[][][]short",
1090         "com.sun.star.beans.XPropertySetInfo",
1091         "type",
1092         "[]string",
1093         "long",
1094         "[]type",
1095         "[]byte",
1096     };
1097     //is() nDemandedPropCount = 22;
1098 
1099 
1100     DefItem pMethodDefs[] =
1101     {
1102         { "queryInterface", MethodConcept_NORMAL_IMPL },
1103         { "acquire", MethodConcept::DANGEROUS },
1104         { "release", MethodConcept::DANGEROUS },
1105         { "writeln", MethodConcept_NORMAL_IMPL },
1106         { "getDroenk", MethodConcept::PROPERTY },
1107         { "getIntroTest", MethodConcept::PROPERTY },
1108         { "getUps", MethodConcept_NORMAL_IMPL },
1109         { "setDroenk", MethodConcept::PROPERTY },
1110         { "getBla", MethodConcept::PROPERTY },
1111         { "setBla", MethodConcept_NORMAL_IMPL },
1112         { "getBlub", MethodConcept::PROPERTY },
1113         { "setBlub", MethodConcept::PROPERTY },
1114         { "getGulp", MethodConcept::PROPERTY },
1115         { "setGulp", MethodConcept_NORMAL_IMPL },
1116         { "getTypeClass", MethodConcept_NORMAL_IMPL },
1117         { "setTypeClass", MethodConcept_NORMAL_IMPL },
1118         { "getStrings", MethodConcept::PROPERTY },
1119         { "setStrings", MethodConcept::PROPERTY },
1120         { "setStringsPerMethod", MethodConcept_NORMAL_IMPL },
1121         { "getMultiSequence", MethodConcept::PROPERTY },
1122         { "setMultiSequence", MethodConcept::PROPERTY },
1123         { "addPropertiesChangeListener", MethodConcept::LISTENER },
1124         { "removePropertiesChangeListener", MethodConcept::LISTENER },
1125         { "getPropertySetInfo", MethodConcept::PROPERTY },
1126         { "setPropertyValue", MethodConcept_NORMAL_IMPL },
1127         { "getPropertyValue", MethodConcept_NORMAL_IMPL },
1128         { "addPropertyChangeListener", MethodConcept::LISTENER },
1129         { "removePropertyChangeListener", MethodConcept::LISTENER },
1130         { "addVetoableChangeListener", MethodConcept::LISTENER },
1131         { "removeVetoableChangeListener", MethodConcept::LISTENER },
1132         { "getElementType", MethodConcept::PROPERTY | MethodConcept::NAMECONTAINER| MethodConcept::INDEXCONTAINER | MethodConcept::ENUMERATION  },
1133         { "hasElements", MethodConcept::NAMECONTAINER | MethodConcept::INDEXCONTAINER | MethodConcept::ENUMERATION },
1134         { "getByName", MethodConcept::NAMECONTAINER },
1135         { "getElementNames", MethodConcept::PROPERTY | MethodConcept::NAMECONTAINER },
1136         { "hasByName", MethodConcept::NAMECONTAINER },
1137         { "getCount", MethodConcept::PROPERTY | MethodConcept::INDEXCONTAINER },
1138         { "getByIndex", MethodConcept::INDEXCONTAINER },
1139         { "getTypes", MethodConcept::PROPERTY },
1140         { "getImplementationId", MethodConcept::PROPERTY },
1141         { "queryAdapter", MethodConcept_NORMAL_IMPL },
1142         { NULL, 0 }
1143     };
1144 
1145     OString aErrorStr;
1146 
1147     //******************************************************
1148 
1149     // Test-Objekt anlegen
1150     Any aObjAny = getIntrospectionTestObject( xMgr );
1151 
1152     // Introspection-Service holen
1153     //Reference< XMultiServiceFactory > xServiceManager(getProcessServiceManager(), USR_QUERY);
1154     //Reference< XIntrospection > xIntrospection( xMgr->createInstance(L"com.sun.star.beans.Introspection"), UNO_QUERY );
1155     //TEST_ENSHURE( xIntrospection.is(), "Creation of introspection instance failed" );
1156     //if( !xIntrospection.is() )
1157         //return sal_False;
1158 
1159     // und unspecten
1160     Reference< XIntrospectionAccess > xAccess = xIntrospection->inspect( aObjAny );
1161     xAccess = xIntrospection->inspect( aObjAny );
1162     xAccess = xIntrospection->inspect( aObjAny );
1163     TEST_ENSHURE( xAccess.is(), "introspection failed, no XIntrospectionAccess returned" );
1164     if( !xAccess.is() )
1165         return sal_False;
1166 
1167     // Ergebnis der Introspection pruefen
1168 
1169     // XPropertySet-UIK ermitteln
1170     Type aType = getCppuType( (Reference< XPropertySet >*) NULL );
1171     //typelib_InterfaceTypeDescription* pTypeDesc = NULL;
1172     //aType.getDescription( (typelib_TypeDescription**)&pTypeDesc );
1173     //Uik aPropertySetUik = *(Uik*)&pTypeDesc->aUik;
1174     //typelib_typedescription_release( (typelib_TypeDescription*)pTypeDesc );
1175 
1176     Reference< XInterface > xPropSetIface = xAccess->queryAdapter( aType );
1177     //Reference< XInterface > xPropSetIface = xAccess->queryAdapter( aPropertySetUik );
1178     Reference< XPropertySet > xPropSet( xPropSetIface, UNO_QUERY );
1179     //XPropertySetRef xPropSet = (XPropertySet*)xPropSetIface->
1180     //  queryInterface( XPropertySet::getSmartUik() );
1181     TEST_ENSHURE( xPropSet.is(), "Could not get XPropertySet by queryAdapter()" );
1182 
1183     // XExactName
1184     Reference< XExactName > xExactName( xAccess, UNO_QUERY );
1185     TEST_ENSHURE( xExactName.is(), "Introspection unterstuetzt kein ExactName" );
1186 
1187     // Schleife ueber alle Kombinationen von Concepts
1188     for( sal_Int32 nConcepts = 0 ; nConcepts < 16 ; nConcepts++ )
1189     {
1190 //printf( "*******************************************************\n" );
1191 //printf( "nConcepts = %ld\n", nConcepts );
1192 
1193         // Wieviele Properties sollten es sein
1194         sal_Int32 nDemandedPropCount = 0;
1195         sal_Int32 iList = 0;
1196         while( pPropertyDefs[ iList ].pName )
1197         {
1198             if( pPropertyDefs[ iList ].nConcept & nConcepts )
1199                 nDemandedPropCount++;
1200             iList++;
1201         }
1202 
1203         if( xPropSet.is() )
1204         {
1205             Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();
1206             //Sequence<Property> aRetSeq = xPropSetInfo->getProperties();
1207             Sequence<Property> aRetSeq = xAccess->getProperties( nConcepts );
1208 
1209             sal_Int32 nLen = aRetSeq.getLength();
1210 
1211             aErrorStr  = "Expected to find ";
1212             aErrorStr += OString::valueOf( nDemandedPropCount );
1213             aErrorStr += " properties but found ";
1214             aErrorStr += OString::valueOf( nLen );
1215             TEST_ENSHURE( nLen == nDemandedPropCount, aErrorStr.getStr() );
1216 
1217             // cout << "**********************************\n";
1218             // cout << "*** Ergebnis der Introspection ***\n";
1219             // cout << "**********************************\n";
1220             // cout << "\nIntrospection hat " << nLen << " Properties gefunden:\n";
1221 
1222             const Property* pProps = aRetSeq.getConstArray();
1223             Any aPropVal;
1224             sal_Int32 i;
1225             iList = 0;
1226             for( i = 0 ; i < nLen ; i++ )
1227             {
1228                 const Property aProp = pProps[ i ];
1229 
1230                 // Naechste Passende Methode in der Liste suchen
1231                 while( pPropertyDefs[ iList ].pName )
1232                 {
1233                     if( pPropertyDefs[ iList ].nConcept & nConcepts )
1234                         break;
1235                     iList++;
1236                 }
1237                 sal_Int32 iDemanded = iList;
1238                 iList++;
1239 
1240                 OUString aPropName = aProp.Name;
1241                 OString aNameStr( aPropName.getStr(), aPropName.getLength(), RTL_TEXTENCODING_ASCII_US );
1242                     //UStringToString(aPropName, CHARSET_SYSTEM);
1243 
1244 //printf( "Property = %s\n", aNameStr.getStr() );
1245 
1246                 OString aDemandedName = pPropertyDefs[ iDemanded ].pName;
1247                 //OString aDemandedName = pDemandedPropNames[ i ];
1248                 aErrorStr  = "Expected property \"";
1249                 aErrorStr += aDemandedName;
1250                 aErrorStr += "\", found \"";
1251                 aErrorStr += aNameStr;
1252                 aErrorStr += "\"";
1253                 TEST_ENSHURE( aNameStr == aDemandedName, aErrorStr.getStr() );
1254                 // cout << "Property " << (i+1) << ": \"" << (const char*)UStringToString(aPropName, CHARSET_SYSTEM) << "\"";
1255 
1256 
1257                 Type aPropType = aProp.Type;
1258                 OString aTypeNameStr( OUStringToOString(aPropType.getTypeName(), RTL_TEXTENCODING_ASCII_US) );
1259                 //Reference< XIdlClass > xPropType = aProp.Type;
1260                 //OString aTypeNameStr( xPropType->getName(), xPropType->getName().getLength(), RTL_TEXTENCODING_ASCII_US );
1261                 OString aDemandedTypeNameStr = pDemandedPropTypes[ iDemanded ];
1262                 //OString aDemandedTypeNameStr = pDemandedPropTypes[ i ];
1263                 aErrorStr  = "Property \"";
1264                 aErrorStr += aDemandedName;
1265                 aErrorStr += "\", expected type >";
1266                 aErrorStr += aDemandedTypeNameStr;
1267                 aErrorStr += "< found type >";
1268                 aErrorStr += aTypeNameStr;
1269                 aErrorStr += "<";
1270                 TEST_ENSHURE( aTypeNameStr == aDemandedTypeNameStr, aErrorStr.getStr() );
1271                 // cout << " (Prop-Typ: " << (const char*)UStringToString(xPropType->getName(), CHARSET_SYSTEM) << ")";
1272 
1273                 // Wert des Property lesen und ausgeben
1274                 aPropVal = xPropSet->getPropertyValue( aPropName );
1275                 // cout << "\n\tWert = " << (const char*)UStringToString(AnyToString( aPropVal, sal_True ), CHARSET_SYSTEM);
1276 
1277                 OString aValStr = OUStringToOString( AnyToString( aPropVal, sal_False, xMgr ), RTL_TEXTENCODING_ASCII_US );
1278                 OString aDemandedValStr = pDemandedPropVals[ iDemanded ];
1279                 //OString aDemandedValStr = pDemandedPropVals[ i ];
1280                 aErrorStr  = "Property \"";
1281                 aErrorStr += aDemandedName;
1282                 aErrorStr += "\", expected val >";
1283                 aErrorStr += aDemandedValStr;
1284                 aErrorStr += "< found val >";
1285                 aErrorStr += aValStr;
1286                 aErrorStr += "<";
1287                 TEST_ENSHURE( aValStr == aDemandedValStr, aErrorStr.getStr() );
1288 
1289                 // Wert pruefen und typgerecht modifizieren
1290                 TypeClass eType = aPropVal.getValueType().getTypeClass();
1291                 //Reference< XIdlClass > xIdlClass = aPropVal.getReflection()->getIdlClass();
1292                 //TypeClass eType = xIdlClass->getTypeClass();
1293                 Any aNewVal;
1294                 sal_Bool bModify = sal_True;
1295                 switch( eType )
1296                 {
1297                     case TypeClass_STRING:
1298                     {
1299                         OUString aStr;
1300                         aPropVal >>= aStr;
1301                         //OString aStr = aPropVal.getString();
1302                         aStr = aStr + OUString::createFromAscii(" (Modified!)");
1303                         aNewVal <<= aStr;
1304                         break;
1305                     }
1306                     case TypeClass_DOUBLE:
1307                     {
1308                         double d(0.0);
1309                         aPropVal >>= d;
1310                         aNewVal <<= d + 1.0;
1311                         break;
1312                     }
1313                     case TypeClass_SHORT:
1314                     {
1315                         sal_Int16 n(0);
1316                         aPropVal >>= n;
1317                         aNewVal <<= sal_Int16( n + 1 );
1318                         break;
1319                     }
1320                     case TypeClass_LONG:
1321                     {
1322                         sal_Int32 n(0);
1323                         aPropVal >>= n;
1324                         aNewVal <<= sal_Int32( n + 1 );
1325                         break;
1326                     }
1327                     default:
1328                         bModify = sal_False;
1329                         break;
1330                 }
1331 
1332                 // Modifizieren nur beim letzten Durchlauf
1333                 if( nConcepts == 15 )
1334                 {
1335                     // XExactName pruefen, dafuer alles gross machen
1336                     // (Introspection ist mit LowerCase implementiert, also anders machen)
1337                     OUString aUpperUStr = aPropName.toAsciiUpperCase();
1338                     OUString aExactName = xExactName->getExactName( aUpperUStr );
1339                     if( aExactName != aPropName )
1340                     {
1341                         aErrorStr  = "Property \"";
1342                         aErrorStr += OUStringToOString( aPropName, RTL_TEXTENCODING_ASCII_US );
1343                         aErrorStr += "\", not found as \"";
1344                         aErrorStr += OUStringToOString(aUpperUStr, RTL_TEXTENCODING_ASCII_US );
1345                         aErrorStr += "\" using XExactName";
1346                         TEST_ENSHURE( sal_False, aErrorStr.getStr() );
1347                     }
1348                 }
1349                 else
1350                 {
1351                     bModify = sal_False;
1352                 }
1353 
1354                 // Neuen Wert setzen, wieder lesen und ausgeben
1355                 if( bModify )
1356                 {
1357                     // cout.flush();
1358 
1359                     // 1.7.1999, UnknownPropertyException bei ReadOnly-Properties abfangen
1360                     try
1361                     {
1362                         xPropSet->setPropertyValue( aPropName, aNewVal );
1363                     }
1364                     catch(UnknownPropertyException e1)
1365                     {
1366                     }
1367 
1368                     aPropVal = xPropSet->getPropertyValue( aPropName );
1369                     // cout << "\n\tModifizierter Wert = " << (const char*) UStringToString(AnyToString( aPropVal, sal_True ), CHARSET_SYSTEM) << "\n";
1370 
1371                     OUString aStr = AnyToString( aPropVal, sal_False, xMgr );
1372                     OString aModifiedValStr = OUStringToOString( aStr, RTL_TEXTENCODING_ASCII_US );
1373                     OString aDemandedModifiedValStr = pDemandedModifiedPropVals[ i ];
1374                     aErrorStr  = "Property \"";
1375                     aErrorStr += aDemandedName;
1376                     aErrorStr += "\", expected modified val >";
1377                     aErrorStr += aDemandedModifiedValStr;
1378                     aErrorStr += "< found val >";
1379                     aErrorStr += aModifiedValStr;
1380                     aErrorStr += "<";
1381                     TEST_ENSHURE( aModifiedValStr == aDemandedModifiedValStr, aErrorStr.getStr() );
1382                 }
1383                 else
1384                 {
1385                     // cout << "\n\tWert wurde nicht modifiziert\n";
1386                 }
1387 
1388                 // Checken, ob alle Properties auch einzeln gefunden werden
1389                 aErrorStr  = "property \"";
1390                 aErrorStr += aDemandedName;
1391                 aErrorStr += "\" not found with hasProperty()";
1392                 OUString aWDemandedName = OStringToOUString(aDemandedName, RTL_TEXTENCODING_ASCII_US );
1393                 sal_Bool bProperty = xAccess->hasProperty( aWDemandedName, nConcepts );
1394                 //sal_Bool bProperty = xAccess->hasProperty( aWDemandedName, PropertyConcept::ALL - PropertyConcept::DANGEROUS );
1395                 TEST_ENSHURE( bProperty, aErrorStr.getStr() );
1396 
1397                 aErrorStr  = "property \"";
1398                 aErrorStr += aDemandedName;
1399                 aErrorStr += "\" not equal to same Property in sequence returned by getProperties()";
1400                 try
1401                 {
1402                     Property aGetProp = xAccess->getProperty( aWDemandedName, nConcepts );
1403                     //Property aGetProp = xAccess->getProperty( aWDemandedName, PropertyConcept::ALL );
1404                     //TEST_ENSHURE( aGetProp == aProp , aErrorStr.getStr() );
1405                 }
1406                 catch (RuntimeException e1)
1407                 {
1408                     aErrorStr  = "property \"";
1409                     aErrorStr += aDemandedName;
1410                     aErrorStr += "\", exception was thrown when trying getProperty()";
1411                     TEST_ENSHURE( sal_False, aErrorStr.getStr() );
1412                 }
1413 
1414             }
1415         }
1416     }
1417 
1418     // Schleife ueber alle Kombinationen von Concepts
1419     for( sal_Int32 nConcepts = 0 ; nConcepts < 128 ; nConcepts++ )
1420     {
1421 //printf( "*******************************************************\n" );
1422 //printf( "nConcepts = %ld\n", nConcepts );
1423 
1424         // Das 2^6-Bit steht fuer "den Rest"
1425         sal_Int32 nRealConcepts = nConcepts;
1426         if( nConcepts & 0x40 )
1427             nRealConcepts |= (0xFFFFFFFF - 0x3F);
1428 
1429         // Wieviele Methoden sollten es sein
1430         sal_Int32 nDemandedMethCount = 0;
1431         sal_Int32 iList = 0;
1432         while( pMethodDefs[ iList ].pName )
1433         {
1434             if( pMethodDefs[ iList ].nConcept & nRealConcepts )
1435                 nDemandedMethCount++;
1436             iList++;
1437         }
1438 
1439         // Methoden-Array ausgeben
1440         //aMethodSeq = xAccess->getMethods
1441         Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods( nRealConcepts );
1442         //Sequence<XIdlMethodRef> aMethodSeq = xAccess->getMethods
1443         //  ( MethodConcept::ALL - MethodConcept::DANGEROUS - MethodConcept::PROPERTY );
1444         sal_Int32 nLen = aMethodSeq.getLength();
1445         // cout << "\n\n*** Methoden ***\n";
1446         // cout << "Introspection hat " << nLen << " Methoden gefunden:\n";
1447 
1448         aErrorStr  = "Expected to find ";
1449         aErrorStr += OString::valueOf( nDemandedMethCount );
1450         aErrorStr += " methods but found ";
1451         aErrorStr += OString::valueOf( nLen );
1452         TEST_ENSHURE( nLen == nDemandedMethCount, aErrorStr.getStr() );
1453 
1454         const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
1455         sal_Int32 i;
1456         iList = 0;
1457 
1458         for( i = 0 ; i < nLen ; i++ )
1459         {
1460             // Methode ansprechen
1461             const Reference< XIdlMethod >& rxMethod = pMethods[i];
1462 
1463             // Methode ausgeben
1464             OUString aMethName = rxMethod->getName();
1465             OString aNameStr = OUStringToOString(aMethName, RTL_TEXTENCODING_ASCII_US );
1466 
1467 //printf( "Method = %s\n", aNameStr.getStr() );
1468 
1469             // Naechste Passende Methode in der Liste suchen
1470             while( pMethodDefs[ iList ].pName )
1471             {
1472                 if( pMethodDefs[ iList ].nConcept & nRealConcepts )
1473                     break;
1474                 iList++;
1475             }
1476             OString aDemandedName = pMethodDefs[ iList ].pName;
1477             iList++;
1478 
1479             //OString aDemandedName = pDemandedMethNames[ i ];
1480             aErrorStr  = "Expected method \"";
1481             aErrorStr += aDemandedName;
1482             aErrorStr += "\", found \"";
1483             aErrorStr += aNameStr;
1484             aErrorStr += "\"";
1485             TEST_ENSHURE( aNameStr == aDemandedName, aErrorStr.getStr() );
1486             // cout << "Methode " << (i+1) << ": " << (const char*) UStringToString(rxMethod->getReturnType()->getName(), CHARSET_SYSTEM)
1487             //   << " " << (const char*) UStringToString(rxMethod->getName(), CHARSET_SYSTEM) << "( ";
1488 
1489             // Checken, ob alle Methoden auch einzeln gefunden werden
1490             aErrorStr  = "method \"";
1491             aErrorStr += aDemandedName;
1492             aErrorStr += "\" not found with hasMethod()";
1493             OUString aWDemandedName = OStringToOUString(aDemandedName, RTL_TEXTENCODING_ASCII_US );
1494             sal_Bool bMethod = xAccess->hasMethod( aWDemandedName, nRealConcepts );
1495             //sal_Bool bMethod = xAccess->hasMethod( aWDemandedName, MethodConcept::ALL );
1496             TEST_ENSHURE( bMethod, aErrorStr.getStr() );
1497 
1498             aErrorStr  = "method \"";
1499             aErrorStr += aDemandedName;
1500             aErrorStr += "\" not equal to same method in sequence returned by getMethods()";
1501             try
1502             {
1503                 Reference< XIdlMethod > xGetMethod = xAccess->getMethod( aWDemandedName, nRealConcepts );
1504                 //XIdlMethodRef xGetMethod = xAccess->getMethod( aWDemandedName, MethodConcept::ALL );
1505                 TEST_ENSHURE( xGetMethod == rxMethod , aErrorStr.getStr() );
1506             }
1507             catch (RuntimeException e1)
1508             {
1509                 aErrorStr  = "method \"";
1510                 aErrorStr += aDemandedName;
1511                 aErrorStr += "\", exception was thrown when trying getMethod()";
1512                 TEST_ENSHURE( sal_False, aErrorStr.getStr() );
1513             }
1514         }
1515     }
1516 
1517     // Listener-Klassen ausgeben
1518     Sequence< Type > aClassSeq = xAccess->getSupportedListeners();
1519     sal_Int32 nLen = aClassSeq.getLength();
1520     // cout << "\n\n*** Anmeldbare Listener ***\n";
1521     // cout << "Introspection hat " << nLen << " Listener gefunden:\n";
1522 
1523     const Type* pListeners = aClassSeq.getConstArray();
1524     for( sal_Int32 i = 0 ; i < nLen ; i++ )
1525     {
1526         // Methode ansprechen
1527         const Type& aListenerType = pListeners[i];
1528 
1529         // Namen besorgen
1530         OUString aListenerClassName = aListenerType.getTypeName();
1531         // cout << "Listener " << (i+1) << ": " << (const char*)UStringToString(aListenerClassName, CHARSET_SYSTEM) << "\n";
1532     }
1533 
1534 
1535     // Performance bei hasMethod testen.
1536     //CheckMethodPerformance( xAccess, "queryInterface", 100000 );
1537     //CheckMethodPerformance( xAccess, "getIdlClasses", 100000 );
1538 
1539     // cout.flush();
1540 
1541 
1542 
1543 
1544     return sal_True;
1545 }
1546 
1547 
1548 SAL_IMPLEMENT_MAIN()
1549 {
1550     Reference< XMultiServiceFactory > xMgr( createRegistryServiceFactory( OUString::createFromAscii("stoctest.rdb") ) );
1551 
1552     sal_Bool bSucc = sal_False;
1553     try
1554     {
1555         Reference< XImplementationRegistration > xImplReg(
1556             xMgr->createInstance( OUString::createFromAscii("com.sun.star.registry.ImplementationRegistration") ), UNO_QUERY );
1557         OSL_ENSURE( xImplReg.is(), "### no impl reg!" );
1558 
1559         // Register services
1560         OUString libName( RTL_CONSTASCII_USTRINGPARAM(
1561                               "reflection.uno" SAL_DLLEXTENSION) );
1562 //          ORealDynamicLoader::computeLibraryName( OUString::createFromAscii("corefl"), libName);
1563         fprintf(stderr, "1\n" );
1564         xImplReg->registerImplementation(OUString::createFromAscii("com.sun.star.loader.SharedLibrary"),
1565                                          libName, Reference< XSimpleRegistry >() );
1566         fprintf(stderr, "2\n" );
1567         Reference< XIdlReflection > xRefl( xMgr->createInstance( OUString::createFromAscii("com.sun.star.reflection.CoreReflection") ), UNO_QUERY );
1568         OSL_ENSURE( xRefl.is(), "### no corereflection!" );
1569 
1570         // Introspection
1571         libName = OUString::createFromAscii(
1572             "introspection.uno" SAL_DLLEXTENSION);
1573 //          ORealDynamicLoader::computeLibraryName( OUString::createFromAscii("insp"), libName);
1574         fprintf(stderr, "3\n" );
1575         xImplReg->registerImplementation(OUString::createFromAscii("com.sun.star.loader.SharedLibrary"),
1576                                          libName, Reference< XSimpleRegistry >() );
1577         fprintf(stderr, "4\n" );
1578         Reference< XIntrospection > xIntrosp( xMgr->createInstance( OUString::createFromAscii("com.sun.star.beans.Introspection") ), UNO_QUERY );
1579         OSL_ENSURE( xRefl.is(), "### no corereflection!" );
1580 
1581         fprintf(stderr, "before test_introsp\n" );
1582         bSucc = test_introsp( xMgr, xRefl, xIntrosp );
1583         fprintf(stderr, "after test_introsp\n" );
1584         //bSucc = test_corefl( xRefl );
1585     }
1586     catch (Exception & rExc)
1587     {
1588         OSL_ENSURE( sal_False, "### exception occured!" );
1589         OString aMsg( OUStringToOString( rExc.Message, RTL_TEXTENCODING_ASCII_US ) );
1590         OSL_TRACE( "### exception occured: " );
1591         OSL_TRACE( aMsg.getStr() );
1592         OSL_TRACE( "\n" );
1593     }
1594 
1595     Reference< XComponent >( xMgr, UNO_QUERY )->dispose();
1596 
1597     printf( "testintrosp %s !\n", (bSucc ? "succeeded" : "failed") );
1598     return (bSucc ? 0 : -1);
1599 }
1600 
1601 
1602 
1603 
1604 
1605 
1606 
1607 //*****************************
1608 //*** TEST-Implementationen ***
1609 //*****************************
1610 // Bleibt auf Dauer nicht drin, dient als exportierbare Test-Klasse
1611 // z.B. fuer Basic-Anbindung
1612 
1613 
1614 
1615 
1616 
1617 
1618