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