1628 lines
61 KiB
C++
1628 lines
61 KiB
C++
/*************************************************************************
|
||
*
|
||
* OpenOffice.org - a multi-platform office productivity suite
|
||
*
|
||
* $RCSfile: testintrosp.cxx,v $
|
||
*
|
||
* $Revision: 1.15 $
|
||
*
|
||
* last change: $Author: rt $ $Date: 2006-12-01 17:22:35 $
|
||
*
|
||
* The Contents of this file are made available subject to
|
||
* the terms of GNU Lesser General Public License Version 2.1.
|
||
*
|
||
*
|
||
* GNU Lesser General Public License Version 2.1
|
||
* =============================================
|
||
* Copyright 2005 by Sun Microsystems, Inc.
|
||
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License version 2.1, as published by the Free Software Foundation.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, write to the Free Software
|
||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
||
* MA 02111-1307 USA
|
||
*
|
||
************************************************************************/
|
||
|
||
// MARKER(update_precomp.py): autogen include statement, do not remove
|
||
#include "precompiled_stoc.hxx"
|
||
|
||
#include <sal/main.h>
|
||
#include <cppuhelper/implbase1.hxx>
|
||
#include <cppuhelper/implbase4.hxx>
|
||
#include <cppuhelper/servicefactory.hxx>
|
||
|
||
#ifndef _OSL_DIAGNOSE_H_
|
||
#include <osl/diagnose.h>
|
||
#endif
|
||
|
||
//#include <vos/dynload.hxx>
|
||
|
||
#include <ModuleA/XIntroTest.hpp>
|
||
#include <com/sun/star/beans/XPropertySet.hpp>
|
||
#include <com/sun/star/beans/XIntrospection.hpp>
|
||
#include <com/sun/star/beans/PropertyAttribute.hpp>
|
||
#include <com/sun/star/beans/PropertyConcept.hpp>
|
||
#include <com/sun/star/beans/MethodConcept.hpp>
|
||
#include <com/sun/star/beans/XExactName.hpp>
|
||
#include <com/sun/star/container/XElementAccess.hpp>
|
||
#include <com/sun/star/container/XNameAccess.hpp>
|
||
#include <com/sun/star/container/XIndexAccess.hpp>
|
||
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
|
||
#include <com/sun/star/reflection/XIdlReflection.hpp>
|
||
//#include <com/sun/star/registry/XSimpleRegistry.hpp>
|
||
#include <com/sun/star/registry/XImplementationRegistration.hpp>
|
||
#include <com/sun/star/lang/XComponent.hpp>
|
||
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
|
||
|
||
using namespace rtl;
|
||
using namespace cppu;
|
||
//using namespace vos;
|
||
using namespace ModuleA;
|
||
//using namespace ModuleB;
|
||
//using namespace ModuleC;
|
||
//using namespace ModuleA::ModuleB;
|
||
using namespace com::sun::star::uno;
|
||
using namespace com::sun::star::lang;
|
||
using namespace com::sun::star::beans;
|
||
using namespace com::sun::star::registry;
|
||
using namespace com::sun::star::reflection;
|
||
using namespace com::sun::star::container;
|
||
using namespace com::sun::star::beans::PropertyAttribute;
|
||
|
||
|
||
typedef WeakImplHelper4< XIntroTest, XPropertySet, XNameAccess, XIndexAccess > ImplIntroTestHelper;
|
||
typedef WeakImplHelper1< XPropertySetInfo > ImplPropertySetInfoHelper;
|
||
|
||
|
||
#define DEFAULT_INDEX_ACCESS_COUNT 10
|
||
#define DEFAULT_NAME_ACCESS_COUNT 5
|
||
|
||
#if OSL_DEBUG_LEVEL > 0
|
||
#define TEST_ENSHURE(c, m) OSL_ENSURE(c, m)
|
||
#else
|
||
#define TEST_ENSHURE(c, m) OSL_VERIFY(c)
|
||
#endif
|
||
|
||
//class IntroTestWritelnOutput;
|
||
|
||
|
||
|
||
//**************************************************************
|
||
//*** Hilfs-Funktion, um vom Type eine XIdlClass zu bekommen ***
|
||
//**************************************************************
|
||
Reference<XIdlClass> TypeToIdlClass( const Type& rType, const Reference< XMultiServiceFactory > & xMgr )
|
||
{
|
||
static Reference< XIdlReflection > xRefl;
|
||
|
||
// void als Default-Klasse eintragen
|
||
Reference<XIdlClass> xRetClass;
|
||
typelib_TypeDescription * pTD = 0;
|
||
rType.getDescription( &pTD );
|
||
if( pTD )
|
||
{
|
||
OUString sOWName( pTD->pTypeName );
|
||
if( !xRefl.is() )
|
||
{
|
||
xRefl = Reference< XIdlReflection >( xMgr->createInstance(
|
||
OUString::createFromAscii("com.sun.star.reflection.CoreReflection") ), UNO_QUERY );
|
||
OSL_ENSURE( xRefl.is(), "### no corereflection!" );
|
||
}
|
||
xRetClass = xRefl->forName( sOWName );
|
||
}
|
||
return xRetClass;
|
||
}
|
||
|
||
|
||
//****************************************************
|
||
//*** Hilfs-Funktion, um Any als UString auszugeben ***
|
||
//****************************************************
|
||
// ACHTUNG: Kann mal an eine zentrale Stelle uebernommen werden
|
||
// Wird zunaechst nur fuer einfache Datentypen ausgefuehrt
|
||
|
||
OUString AnyToString( const Any& aValue, sal_Bool bIncludeType, const Reference< XMultiServiceFactory > & xMgr )
|
||
{
|
||
Type aValType = aValue.getValueType();
|
||
TypeClass eType = aValType.getTypeClass();
|
||
char pBuffer[50];
|
||
|
||
OUString aRetStr;
|
||
switch( eType )
|
||
{
|
||
case TypeClass_TYPE: aRetStr = OUString::createFromAscii("TYPE TYPE"); break;
|
||
case TypeClass_INTERFACE: aRetStr = OUString::createFromAscii("TYPE INTERFACE"); break;
|
||
case TypeClass_SERVICE: aRetStr = OUString::createFromAscii("TYPE SERVICE"); break;
|
||
case TypeClass_STRUCT: aRetStr = OUString::createFromAscii("TYPE STRUCT"); break;
|
||
case TypeClass_TYPEDEF: aRetStr = OUString::createFromAscii("TYPE TYPEDEF"); break;
|
||
case TypeClass_UNION: aRetStr = OUString::createFromAscii("TYPE UNION"); break;
|
||
case TypeClass_ENUM: aRetStr = OUString::createFromAscii("TYPE ENUM"); break;
|
||
case TypeClass_EXCEPTION: aRetStr = OUString::createFromAscii("TYPE EXCEPTION"); break;
|
||
case TypeClass_ARRAY: aRetStr = OUString::createFromAscii("TYPE ARRAY"); break;
|
||
case TypeClass_SEQUENCE: aRetStr = OUString::createFromAscii("TYPE SEQUENCE"); break;
|
||
case TypeClass_VOID: aRetStr = OUString::createFromAscii("TYPE void"); break;
|
||
case TypeClass_ANY: aRetStr = OUString::createFromAscii("TYPE any"); break;
|
||
case TypeClass_UNKNOWN: aRetStr = OUString::createFromAscii("TYPE unknown"); break;
|
||
case TypeClass_BOOLEAN:
|
||
{
|
||
sal_Bool b = *(sal_Bool*)aValue.getValue();
|
||
//aRet.setValue( &b, getCppuBooleanType() );
|
||
//aValue >>= b;
|
||
aRetStr = OUString::valueOf( b );
|
||
break;
|
||
}
|
||
case TypeClass_CHAR:
|
||
{
|
||
sal_Unicode c = *(sal_Unicode*)aValue.getValue();
|
||
//aValue >>= c;
|
||
//getCppuCharType()
|
||
aRetStr = OUString::valueOf( c );
|
||
break;
|
||
}
|
||
case TypeClass_STRING:
|
||
{
|
||
aValue >>= aRetStr;
|
||
break;
|
||
}
|
||
case TypeClass_FLOAT:
|
||
{
|
||
float f;
|
||
aValue >>= f;
|
||
snprintf( pBuffer, sizeof( pBuffer ), "%f", f );
|
||
aRetStr = OUString( pBuffer, strlen( pBuffer ), RTL_TEXTENCODING_ASCII_US );
|
||
break;
|
||
}
|
||
case TypeClass_DOUBLE:
|
||
{
|
||
double d;
|
||
aValue >>= d;
|
||
snprintf( pBuffer, sizeof( pBuffer ), "%f", d );
|
||
aRetStr = OUString( pBuffer, strlen( pBuffer ), RTL_TEXTENCODING_ASCII_US );
|
||
break;
|
||
}
|
||
case TypeClass_BYTE:
|
||
{
|
||
sal_Int8 n;
|
||
aValue >>= n;
|
||
aRetStr = OUString::valueOf( (sal_Int32) n );
|
||
break;
|
||
}
|
||
case TypeClass_SHORT:
|
||
{
|
||
sal_Int16 n;
|
||
aValue >>= n;
|
||
aRetStr = OUString::valueOf( (sal_Int32) n );
|
||
break;
|
||
}
|
||
case TypeClass_LONG:
|
||
{
|
||
sal_Int32 n;
|
||
aValue >>= n;
|
||
aRetStr = OUString::valueOf( n );
|
||
break;
|
||
}
|
||
/*
|
||
case TypeClass_HYPER:
|
||
{
|
||
aRetStr = L"TYPE HYPER";
|
||
break;
|
||
}
|
||
case TypeClass_UNSIGNED_SHORT:
|
||
{
|
||
aRetStr = StringToUString(WSString(aValue.getUINT16()), CHARSET_SYSTEM);
|
||
break;
|
||
}
|
||
case TypeClass_UNSIGNED_LONG:
|
||
{
|
||
aRetStr = StringToUString(WSString(aValue.getUINT32()), CHARSET_SYSTEM);
|
||
break;
|
||
}
|
||
case TypeClass_UNSIGNED_HYPER:
|
||
{
|
||
aRetStr = L"TYPE UNSIGNED_HYPER";
|
||
break;
|
||
}
|
||
*/
|
||
default: ;
|
||
}
|
||
|
||
if( bIncludeType )
|
||
{
|
||
Reference< XIdlClass > xIdlClass = TypeToIdlClass( aValType, xMgr );
|
||
aRetStr = aRetStr + OUString( OUString::createFromAscii(" (Typ: ") ) + xIdlClass->getName() + OUString::createFromAscii(")");
|
||
}
|
||
return aRetStr;
|
||
}
|
||
|
||
/*
|
||
// Hilfs-Funktion, um ein UString in einen Any zu konvertieren
|
||
UsrAny StringToAny( UString aStr, TypeClass eTargetType )
|
||
{
|
||
UsrAny aRetAny;
|
||
switch( eTargetType )
|
||
{
|
||
case TypeClass_INTERFACE: break;
|
||
case TypeClass_SERVICE: break;
|
||
case TypeClass_STRUCT: break;
|
||
case TypeClass_TYPEDEF: break;
|
||
case TypeClass_UNION: break;
|
||
case TypeClass_ENUM: break;
|
||
case TypeClass_EXCEPTION: break;
|
||
case TypeClass_ARRAY: break;
|
||
case TypeClass_SEQUENCE: break;
|
||
case TypeClass_VOID: break;
|
||
case TypeClass_ANY: break;
|
||
case TypeClass_UNKNOWN: break;
|
||
case TypeClass_BOOLEAN: aRetAny.setBOOL( short(aStr)!=0 ); break;
|
||
case TypeClass_CHAR: aRetAny.setChar( char(aStr) ); break;
|
||
case TypeClass_STRING: aRetAny.setString( aStr ); break;
|
||
case TypeClass_FLOAT: aRetAny.setFloat( (float)strtod( aStr.GetStr(), NULL ) ); break;
|
||
case TypeClass_DOUBLE: aRetAny.setDouble( strtod( aStr.GetStr(), NULL ) ); break;
|
||
case TypeClass_BYTE: aRetAny.setBYTE( BYTE(short(aStr)) ); break;
|
||
case TypeClass_SHORT: aRetAny.setINT16( short(aStr) ); break;
|
||
case TypeClass_LONG: aRetAny.setINT32( long(aStr) ); break;
|
||
case TypeClass_HYPER: break;
|
||
case TypeClass_UNSIGNED_SHORT: aRetAny.setUINT16( USHORT(aStr) ); break;
|
||
case TypeClass_UNSIGNED_LONG: aRetAny.setUINT32( ULONG(aStr) ); break;
|
||
case TypeClass_UNSIGNED_HYPER: break;
|
||
}
|
||
return aRetAny;
|
||
}
|
||
*/
|
||
|
||
|
||
//*****************************************
|
||
//*** XPropertySetInfo fuer Test-Klasse ***
|
||
//*****************************************
|
||
|
||
class ImplPropertySetInfo : public ImplPropertySetInfoHelper
|
||
{
|
||
friend class ImplIntroTest;
|
||
|
||
Reference< XMultiServiceFactory > mxMgr;
|
||
|
||
public:
|
||
ImplPropertySetInfo( const Reference< XMultiServiceFactory > & xMgr )
|
||
: mxMgr( xMgr ) {}
|
||
//: mxMgr( xMgr ), ImplPropertySetInfoHelper( xMgr ) {}
|
||
|
||
/*
|
||
// Methoden von XInterface
|
||
virtual sal_Bool SAL_CALL queryInterface( const Uik & rUik, Any & ifc ) throw( RuntimeException );
|
||
virtual void SAL_CALL acquire() throw() { OWeakObject::acquire(); }
|
||
virtual void SAL_CALL release() throw() { OWeakObject::release(); }
|
||
//ALT: sal_Bool queryInterface( Uik aUik, Reference<XInterface> & rOut );
|
||
*/
|
||
|
||
// Methods of XPropertySetInfo
|
||
virtual Sequence< Property > SAL_CALL getProperties( )
|
||
throw(RuntimeException);
|
||
virtual Property SAL_CALL getPropertyByName( const OUString& aName )
|
||
throw(UnknownPropertyException, RuntimeException);
|
||
virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
|
||
throw(RuntimeException);
|
||
//virtual Sequence< Property > SAL_CALL getProperties(void) throw( RuntimeException );
|
||
//virtual Property SAL_CALL getPropertyByName(const OUString& Name) throw( RuntimeException );
|
||
//virtual sal_Bool SAL_CALL hasPropertyByName(const OUString& Name) throw( RuntimeException );
|
||
};
|
||
|
||
|
||
/*
|
||
// Methoden von XInterface
|
||
sal_Bool SAL_CALL ImplPropertySetInfo::queryInterface( const Uik & rUik, Any & ifc )
|
||
throw( RuntimeException )
|
||
{
|
||
// PropertySet-Implementation
|
||
if( com::sun::star::uno::queryInterface( rUik, ifc,
|
||
SAL_STATIC_CAST(XPropertySetInfo*, this) ) )
|
||
return sal_True;
|
||
|
||
return OWeakObject::queryInterface( rUik, ifc );
|
||
}
|
||
|
||
sal_Bool ImplPropertySetInfo::queryInterface( Uik aUik, Reference<XInterface> & rOut )
|
||
{
|
||
if( aUik == XPropertySetInfo::getSmartUik() )
|
||
rOut = (XPropertySetInfo *)this;
|
||
else
|
||
UsrObject::queryInterface( aUik, rOut );
|
||
return rOut.is();
|
||
}
|
||
*/
|
||
|
||
Sequence< Property > ImplPropertySetInfo::getProperties(void)
|
||
throw( RuntimeException )
|
||
{
|
||
static Sequence<Property> * pSeq = NULL;
|
||
|
||
if( !pSeq )
|
||
{
|
||
// die Informationen f<>r die Properties "Width", "Height" und "Name" anlegen
|
||
pSeq = new Sequence<Property>( 3 );
|
||
Property * pAry = pSeq->getArray();
|
||
|
||
pAry[0].Name = OUString::createFromAscii("Factor");
|
||
pAry[0].Handle = -1;
|
||
pAry[0].Type = getCppuType( (double*) NULL );
|
||
//pAry[0].Type = TypeToIdlClass( getCppuType( (double*) NULL ), mxMgr );
|
||
//pAry[0].Type = Double_getReflection()->getIdlClass();
|
||
pAry[0].Attributes = BOUND | TRANSIENT;
|
||
|
||
pAry[1].Name = OUString::createFromAscii("MyCount");
|
||
pAry[1].Handle = -1;
|
||
pAry[1].Type = getCppuType( (sal_Int32*) NULL );
|
||
//pAry[1].Type = TypeToIdlClass( getCppuType( (sal_Int32*) NULL ), mxMgr );
|
||
//pAry[1].Type = INT32_getReflection()->getIdlClass();
|
||
pAry[1].Attributes = BOUND | TRANSIENT;
|
||
|
||
pAry[2].Name = OUString::createFromAscii("Info");
|
||
pAry[2].Handle = -1;
|
||
pAry[2].Type = getCppuType( (OUString*) NULL );
|
||
//pAry[2].Type = TypeToIdlClass( getCppuType( (OUString*) NULL ), mxMgr );
|
||
//pAry[2].Type = OUString_getReflection()->getIdlClass();
|
||
pAry[2].Attributes = TRANSIENT;
|
||
}
|
||
// Die Information <20>ber alle drei Properties liefern.
|
||
return *pSeq;
|
||
}
|
||
|
||
Property ImplPropertySetInfo::getPropertyByName(const OUString& Name)
|
||
throw( UnknownPropertyException, RuntimeException )
|
||
{
|
||
Sequence<Property> aSeq = getProperties();
|
||
const Property * pAry = aSeq.getConstArray();
|
||
|
||
for( sal_Int32 i = aSeq.getLength(); i--; )
|
||
{
|
||
if( pAry[i].Name == Name )
|
||
return pAry[i];
|
||
}
|
||
// Property unbekannt, also leere liefern
|
||
return Property();
|
||
}
|
||
|
||
sal_Bool ImplPropertySetInfo::hasPropertyByName(const OUString& Name)
|
||
throw( RuntimeException )
|
||
{
|
||
Sequence<Property> aSeq = getProperties();
|
||
const Property * pAry = aSeq.getConstArray();
|
||
|
||
for( sal_Int32 i = aSeq.getLength(); i--; )
|
||
{
|
||
if( pAry[i].Name == Name )
|
||
return sal_True;
|
||
}
|
||
// Property unbekannt, also leere liefern
|
||
return sal_False;
|
||
}
|
||
|
||
|
||
|
||
|
||
//*****************************************************************
|
||
|
||
|
||
|
||
class ImplIntroTest : public ImplIntroTestHelper
|
||
{
|
||
Reference< XMultiServiceFactory > mxMgr;
|
||
|
||
friend class ImplPropertySetInfo;
|
||
|
||
// Properties fuer das PropertySet
|
||
Any aAnyArray[10];
|
||
|
||
// Optionale Schnittstelle fuer die writeln-Ausgabe
|
||
//IntroTestWritelnOutput* m_pOutput;
|
||
|
||
Reference< XPropertySetInfo > m_xMyInfo;
|
||
|
||
OUString m_ObjectName;
|
||
|
||
sal_Int16 m_nMarkusAge;
|
||
sal_Int16 m_nMarkusChildrenCount;
|
||
|
||
long m_lDroenk;
|
||
sal_Int16 m_nBla;
|
||
sal_Int16 m_nBlub;
|
||
sal_Int16 m_nGulp;
|
||
sal_Int16 m_nLaber;
|
||
TypeClass eTypeClass;
|
||
Sequence< OUString > aStringSeq;
|
||
Sequence< Sequence< Sequence< sal_Int16 > > > aMultSeq;
|
||
Reference< XIntroTest > m_xIntroTest;
|
||
|
||
// Daten fuer NameAccess
|
||
Reference< XIntroTest >* pNameAccessTab;
|
||
|
||
// Daten fuer IndexAccess
|
||
Reference< XIntroTest >* pIndexAccessTab;
|
||
sal_Int16 iIndexAccessCount;
|
||
|
||
// struct-Properties
|
||
Property m_aFirstStruct;
|
||
PropertyValue m_aSecondStruct;
|
||
|
||
// Listener merken (zunaechst einfach, nur einen pro Property)
|
||
Reference< XPropertyChangeListener > aPropChangeListener;
|
||
OUString aPropChangeListenerStr;
|
||
Reference< XVetoableChangeListener > aVetoPropChangeListener;
|
||
OUString aVetoPropChangeListenerStr;
|
||
|
||
void Init( void );
|
||
|
||
public:
|
||
ImplIntroTest( const Reference< XMultiServiceFactory > & xMgr )
|
||
: mxMgr( xMgr )
|
||
//: mxMgr( xMgr ), ImplIntroTestHelper( xMgr )
|
||
{
|
||
Init();
|
||
}
|
||
|
||
/*
|
||
ImplIntroTest( IntroTestWritelnOutput* pOutput_ )
|
||
{
|
||
Init();
|
||
m_pOutput = pOutput_;
|
||
}
|
||
*/
|
||
|
||
//SMART_UNO_DECLARATION(ImplIntroTest,UsrObject);
|
||
|
||
//BOOL queryInterface( Uik aUik, Reference< XInterface > & rOut );
|
||
//Reference< XIdlClass > getIdlClass();
|
||
|
||
// Trotz virtual inline, um Schreibarbeit zu sparen (nur fuer Testzwecke)
|
||
// XPropertySet
|
||
virtual Reference< XPropertySetInfo > SAL_CALL getPropertySetInfo( )
|
||
throw(RuntimeException);
|
||
virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const Any& aValue )
|
||
throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException);
|
||
virtual Any SAL_CALL getPropertyValue( const OUString& PropertyName )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException);
|
||
virtual void SAL_CALL addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
|
||
{}
|
||
virtual void SAL_CALL removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*aListener*/ )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
|
||
{}
|
||
virtual void SAL_CALL addVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
|
||
{}
|
||
virtual void SAL_CALL removeVetoableChangeListener( const OUString& /*PropertyName*/, const Reference< XVetoableChangeListener >& /*aListener*/ )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
|
||
{}
|
||
|
||
/*
|
||
virtual void setIndexedPropertyValue(const OUString& aPropertyName, INT32 nIndex, const Any& aValue) {}
|
||
virtual Any getIndexedPropertyValue(const UString& aPropertyName, INT32 nIndex) const { return Any(); }
|
||
virtual void addPropertyChangeListener(const UString& aPropertyName, const XPropertyChangeListenerRef& aListener)
|
||
THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
|
||
virtual void removePropertyChangeListener(const UString& aPropertyName, const XPropertyChangeListenerRef& aListener)
|
||
THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
|
||
virtual void addVetoableChangeListener(const UString& aPropertyName, const XVetoableChangeListenerRef& aListener)
|
||
THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
|
||
virtual void removeVetoableChangeListener(const UString& aPropertyName, const XVetoableChangeListenerRef& aListener)
|
||
THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) ) {}
|
||
*/
|
||
|
||
// XIntroTest-Methoden
|
||
// Attributes
|
||
virtual OUString SAL_CALL getObjectName() throw(RuntimeException)
|
||
{ return m_ObjectName; }
|
||
virtual void SAL_CALL setObjectName( const OUString& _objectname ) throw(RuntimeException)
|
||
{ m_ObjectName = _objectname; }
|
||
virtual OUString SAL_CALL getFirstName()
|
||
throw(RuntimeException);
|
||
virtual OUString SAL_CALL getLastName() throw(RuntimeException)
|
||
{ return OUString( OUString::createFromAscii("Meyer") ); }
|
||
virtual sal_Int16 SAL_CALL getAge() throw(RuntimeException)
|
||
{ return m_nMarkusAge; }
|
||
virtual sal_Int16 SAL_CALL getChildrenCount() throw(RuntimeException)
|
||
{ return m_nMarkusChildrenCount; }
|
||
virtual void SAL_CALL setChildrenCount( sal_Int16 _childrencount ) throw(RuntimeException)
|
||
{ m_nMarkusChildrenCount = _childrencount; }
|
||
virtual Property SAL_CALL getFirstStruct() throw(RuntimeException)
|
||
{ return m_aFirstStruct; }
|
||
virtual void SAL_CALL setFirstStruct( const Property& _firststruct ) throw(RuntimeException)
|
||
{ m_aFirstStruct = _firststruct; }
|
||
virtual PropertyValue SAL_CALL getSecondStruct() throw(RuntimeException)
|
||
{ return m_aSecondStruct; }
|
||
virtual void SAL_CALL setSecondStruct( const PropertyValue& _secondstruct ) throw(RuntimeException)
|
||
{ m_aSecondStruct = _secondstruct; }
|
||
|
||
// Methods
|
||
virtual void SAL_CALL writeln( const OUString& Text )
|
||
throw(RuntimeException);
|
||
virtual sal_Int32 SAL_CALL getDroenk( ) throw(RuntimeException)
|
||
{ return m_lDroenk; }
|
||
virtual Reference< ::ModuleA::XIntroTest > SAL_CALL getIntroTest( ) throw(RuntimeException);
|
||
virtual sal_Int32 SAL_CALL getUps( sal_Int32 l ) throw(RuntimeException)
|
||
{ return 2*l; }
|
||
virtual void SAL_CALL setDroenk( sal_Int32 l ) throw(RuntimeException)
|
||
{ m_lDroenk = l; }
|
||
virtual sal_Int16 SAL_CALL getBla( ) throw(RuntimeException)
|
||
{ return m_nBla; }
|
||
virtual void SAL_CALL setBla( sal_Int32 n ) throw(RuntimeException)
|
||
{ m_nBla = (sal_Int16)n; }
|
||
virtual sal_Int16 SAL_CALL getBlub( ) throw(RuntimeException)
|
||
{ return m_nBlub; }
|
||
virtual void SAL_CALL setBlub( sal_Int16 n ) throw(RuntimeException)
|
||
{ m_nBlub = n; }
|
||
virtual sal_Int16 SAL_CALL getGulp( ) throw(RuntimeException)
|
||
{ return m_nGulp; }
|
||
virtual sal_Int16 SAL_CALL setGulp( sal_Int16 n ) throw(RuntimeException)
|
||
{ m_nGulp = n; return 1; }
|
||
virtual TypeClass SAL_CALL getTypeClass( sal_Int16 /*n*/ ) throw(RuntimeException)
|
||
{ return eTypeClass; }
|
||
virtual void SAL_CALL setTypeClass( TypeClass t, double /*d1*/, double /*d2*/ ) throw(RuntimeException)
|
||
{ eTypeClass = t; }
|
||
virtual Sequence< OUString > SAL_CALL getStrings( ) throw(RuntimeException)
|
||
{ return aStringSeq; }
|
||
virtual void SAL_CALL setStrings( const Sequence< OUString >& Strings ) throw(RuntimeException)
|
||
{ aStringSeq = Strings; }
|
||
virtual void SAL_CALL setStringsPerMethod( const Sequence< OUString >& Strings, sal_Int16 /*n*/ ) throw(RuntimeException)
|
||
{ aStringSeq = Strings; }
|
||
virtual Sequence< Sequence< Sequence< sal_Int16 > > > SAL_CALL getMultiSequence( ) throw(RuntimeException)
|
||
{ return aMultSeq; }
|
||
virtual void SAL_CALL setMultiSequence( const Sequence< Sequence< Sequence< sal_Int16 > > >& Seq ) throw(RuntimeException)
|
||
{ aMultSeq = Seq; }
|
||
virtual void SAL_CALL addPropertiesChangeListener( const Sequence< OUString >& PropertyNames, const Reference< XPropertiesChangeListener >& Listener )
|
||
throw(RuntimeException);
|
||
virtual void SAL_CALL removePropertiesChangeListener( const Reference< XPropertiesChangeListener >& Listener )
|
||
throw(RuntimeException);
|
||
|
||
|
||
// Methods of XElementAccess
|
||
virtual Type SAL_CALL getElementType( )
|
||
throw(RuntimeException);
|
||
virtual sal_Bool SAL_CALL hasElements( )
|
||
throw(RuntimeException);
|
||
//virtual XIdlClassRef getElementType(void) constTHROWS( (UsrSystemException) );
|
||
//virtual BOOL hasElements(void) const THROWS( (UsrSystemException) );
|
||
|
||
// XNameAccess-Methoden
|
||
// Methods
|
||
virtual Any SAL_CALL getByName( const OUString& aName )
|
||
throw(NoSuchElementException, WrappedTargetException, RuntimeException);
|
||
virtual Sequence< OUString > SAL_CALL getElementNames( )
|
||
throw(RuntimeException);
|
||
virtual sal_Bool SAL_CALL hasByName( const OUString& aName )
|
||
throw(RuntimeException);
|
||
//virtual Any getByName(const UString& Name) const
|
||
//THROWS( (NoSuchElementException, WrappedTargetException, UsrSystemException) );
|
||
//virtual Sequence<UString> getElementNames(void) const THROWS( (UsrSystemException) );
|
||
//virtual BOOL hasByName(const UString& Name) const THROWS( (UsrSystemException) );
|
||
|
||
// XIndexAccess-Methoden
|
||
// Methods
|
||
virtual sal_Int32 SAL_CALL getCount( )
|
||
throw(RuntimeException);
|
||
virtual Any SAL_CALL getByIndex( sal_Int32 Index )
|
||
throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
|
||
//virtual INT32 getCount(void) const THROWS( (UsrSystemException) );
|
||
//virtual Any getByIndex(INT32 Index) const
|
||
//THROWS( (IndexOutOfBoundsException, WrappedTargetException, UsrSystemException) );
|
||
};
|
||
|
||
//SMART_UNO_IMPLEMENTATION(ImplIntroTest,UsrObject)
|
||
|
||
void ImplIntroTest::Init( void )
|
||
{
|
||
// Eindeutigen Namen verpassen
|
||
static sal_Int32 nObjCount = 0;
|
||
OUString aName( OUString::createFromAscii("IntroTest-Obj Nr. ") );
|
||
aName += OUString::valueOf( nObjCount );
|
||
setObjectName( aName );
|
||
|
||
// Properties initialisieren
|
||
aAnyArray[0] <<= 3.14;
|
||
aAnyArray[1] <<= (sal_Int32)42;
|
||
aAnyArray[2] <<= OUString( OUString::createFromAscii("Hallo") );
|
||
|
||
// Output-Interface
|
||
//m_pOutput = NULL;
|
||
|
||
// Einmal fuer den internen Gebrauch die PropertySetInfo abholen
|
||
m_xMyInfo = getPropertySetInfo();
|
||
m_xMyInfo->acquire(); // sonst raucht es am Programm-Ende ab
|
||
|
||
m_nMarkusAge = 33;
|
||
m_nMarkusChildrenCount = 2;
|
||
|
||
m_lDroenk = 314;
|
||
m_nBla = 42;
|
||
m_nBlub = 111;
|
||
m_nGulp = 99;
|
||
m_nLaber = 1;
|
||
eTypeClass = TypeClass_INTERFACE;
|
||
|
||
// String-Sequence intitialisieren
|
||
aStringSeq.realloc( 3 );
|
||
OUString* pStr = aStringSeq.getArray();
|
||
pStr[ 0 ] = OUString( OUString::createFromAscii("String 0") );
|
||
pStr[ 1 ] = OUString( OUString::createFromAscii("String 1") );
|
||
pStr[ 2 ] = OUString( OUString::createFromAscii("String 2") );
|
||
|
||
// structs initialisieren
|
||
m_aFirstStruct.Name = OUString::createFromAscii("FirstStruct-Name");
|
||
m_aFirstStruct.Handle = 77777;
|
||
//XIdlClassRef Type;
|
||
m_aFirstStruct.Attributes = -222;
|
||
|
||
//XInterfaceRef Source;
|
||
Any Value;
|
||
Value <<= 2.718281828459;
|
||
m_aSecondStruct.Value = Value;
|
||
//XIdlClassRef ListenerType;
|
||
m_aSecondStruct.State = PropertyState_DIRECT_VALUE;
|
||
|
||
// IndexAccess
|
||
iIndexAccessCount = DEFAULT_INDEX_ACCESS_COUNT;
|
||
pIndexAccessTab = NULL;
|
||
pNameAccessTab = NULL;
|
||
}
|
||
|
||
/*
|
||
BOOL ImplIntroTest::queryInterface( Uik aUik, XInterfaceRef & rOut )
|
||
{
|
||
if( aUik == XIntroTest::getSmartUik() )
|
||
rOut = (XIntroTest*)this;
|
||
else if( aUik == XPropertySet::getSmartUik() )
|
||
rOut = (XPropertySet*)this;
|
||
else if( aUik == XNameAccess::getSmartUik() )
|
||
rOut = (XNameAccess*)this;
|
||
else if( aUik == XIndexAccess::getSmartUik() )
|
||
rOut = (XIndexAccess*)this;
|
||
else if( aUik == ((XElementAccess*)NULL)->getSmartUik() )
|
||
rOut = (XElementAccess*)(XIndexAccess *)this;
|
||
else
|
||
UsrObject::queryInterface( aUik, rOut );
|
||
return rOut.is();
|
||
}
|
||
|
||
XIdlClassRef ImplIntroTest::getIdlClass()
|
||
{
|
||
static XIdlClassRef xClass = createStandardClass( L"ImplIntroTest",
|
||
UsrObject::getUsrObjectIdlClass(), 4,
|
||
XIntroTest_getReflection(),
|
||
XPropertySet_getReflection(),
|
||
XNameAccess_getReflection(),
|
||
XIndexAccess_getReflection() );
|
||
return xClass;
|
||
}
|
||
*/
|
||
|
||
Reference< XPropertySetInfo > ImplIntroTest::getPropertySetInfo()
|
||
throw(RuntimeException)
|
||
{
|
||
static ImplPropertySetInfo aInfo( mxMgr );
|
||
// Alle Objekt haben die gleichen Properties, deshalb kann
|
||
// die Info f<>r alle gleich sein
|
||
return &aInfo;
|
||
|
||
//if( m_xMyInfo == NULL )
|
||
// ((ImplIntroTest*)this)->m_xMyInfo = new ImplPropertySetInfo( this );
|
||
//return m_xMyInfo;
|
||
}
|
||
|
||
void ImplIntroTest::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
|
||
throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
|
||
//void ImplIntroTest::setPropertyValue( const UString& aPropertyName, const Any& aValue )
|
||
// THROWS( (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, UsrSystemException) )
|
||
{
|
||
if( aPropChangeListener.is() && aPropertyName == aPropChangeListenerStr )
|
||
{
|
||
PropertyChangeEvent aEvt;
|
||
aEvt.Source = (OWeakObject*)this;
|
||
aEvt.PropertyName = aPropertyName;
|
||
aEvt.PropertyHandle = 0L;
|
||
//aEvt.OldValue;
|
||
//aEvt.NewValue;
|
||
//aEvt.PropagationId;
|
||
aPropChangeListener->propertyChange( aEvt );
|
||
}
|
||
if( aVetoPropChangeListener.is() && aPropertyName == aVetoPropChangeListenerStr )
|
||
{
|
||
PropertyChangeEvent aEvt;
|
||
aEvt.Source = (OWeakObject*)this;
|
||
aEvt.PropertyName = aVetoPropChangeListenerStr;
|
||
aEvt.PropertyHandle = 0L;
|
||
//aEvt.OldValue;
|
||
//aEvt.NewValue;
|
||
//aEvt.PropagationId;
|
||
aVetoPropChangeListener->vetoableChange( aEvt );
|
||
}
|
||
|
||
Sequence<Property> aPropSeq = m_xMyInfo->getProperties();
|
||
sal_Int32 nLen = aPropSeq.getLength();
|
||
for( sal_Int32 i = 0 ; i < nLen ; i++ )
|
||
{
|
||
Property aProp = aPropSeq.getArray()[ i ];
|
||
if( aProp.Name == aPropertyName )
|
||
aAnyArray[i] = aValue;
|
||
}
|
||
}
|
||
|
||
Any ImplIntroTest::getPropertyValue( const OUString& PropertyName )
|
||
throw(UnknownPropertyException, WrappedTargetException, RuntimeException)
|
||
//Any ImplIntroTest::getPropertyValue(const UString& aPropertyName) const
|
||
//THROWS( (UnknownPropertyException, WrappedTargetException, UsrSystemException) )
|
||
{
|
||
Sequence<Property> aPropSeq = m_xMyInfo->getProperties();
|
||
sal_Int32 nLen = aPropSeq.getLength();
|
||
for( sal_Int32 i = 0 ; i < nLen ; i++ )
|
||
{
|
||
Property aProp = aPropSeq.getArray()[ i ];
|
||
if( aProp.Name == PropertyName )
|
||
return aAnyArray[i];
|
||
}
|
||
return Any();
|
||
}
|
||
|
||
OUString ImplIntroTest::getFirstName(void)
|
||
throw(RuntimeException)
|
||
{
|
||
return OUString( OUString::createFromAscii("Markus") );
|
||
}
|
||
|
||
void ImplIntroTest::writeln( const OUString& Text )
|
||
throw(RuntimeException)
|
||
{
|
||
OString aStr( Text.getStr(), Text.getLength(), RTL_TEXTENCODING_ASCII_US );
|
||
|
||
// Haben wir ein Output?
|
||
//if( m_pOutput )
|
||
//{
|
||
//m_pOutput->doWriteln( TextStr );
|
||
//}
|
||
// Sonst einfach rausbraten
|
||
//else
|
||
{
|
||
printf( "%s", aStr.getStr() );
|
||
}
|
||
}
|
||
|
||
Reference< XIntroTest > ImplIntroTest::getIntroTest()
|
||
throw(RuntimeException)
|
||
//XIntroTestRef ImplIntroTest::getIntroTest(void) THROWS( (UsrSystemException) )
|
||
{
|
||
if( !m_xIntroTest.is() )
|
||
m_xIntroTest = new ImplIntroTest( mxMgr );
|
||
return m_xIntroTest;
|
||
}
|
||
|
||
// Methoden von XElementAccess
|
||
Type ImplIntroTest::getElementType( )
|
||
throw(RuntimeException)
|
||
//XIdlClassRef ImplIntroTest::getElementType(void) const THROWS( (UsrSystemException) )
|
||
{
|
||
// TODO
|
||
Type aRetType;
|
||
return aRetType;
|
||
//return Reference< XIdlClass >();
|
||
//return Void_getReflection()->getIdlClass();
|
||
}
|
||
|
||
sal_Bool ImplIntroTest::hasElements( )
|
||
throw(RuntimeException)
|
||
//BOOL ImplIntroTest::hasElements(void) const THROWS( (UsrSystemException) )
|
||
{
|
||
return sal_True;
|
||
}
|
||
|
||
// XNameAccess-Methoden
|
||
sal_Int32 getIndexForName( const OUString& ItemName )
|
||
{
|
||
OUString aLeftStr = ItemName.copy( 0, 4 );
|
||
if( aLeftStr == OUString::createFromAscii("Item") )
|
||
{
|
||
// TODO
|
||
OUString aNumStr = ItemName.copy( 4 );
|
||
//sal_Int32 iIndex = (INT32)UStringToString( aNumStr, CHARSET_SYSTEM );
|
||
//if( iIndex < DEFAULT_NAME_ACCESS_COUNT )
|
||
//return iIndex;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
|
||
Any ImplIntroTest::getByName( const OUString& aName )
|
||
throw(NoSuchElementException, WrappedTargetException, RuntimeException)
|
||
//Any ImplIntroTest::getByName(const UString& Name) const
|
||
//THROWS( (NoSuchElementException, WrappedTargetException, UsrSystemException) )
|
||
{
|
||
Any aRetAny;
|
||
|
||
if( !pNameAccessTab )
|
||
((ImplIntroTest*)this)->pNameAccessTab = new Reference< XIntroTest >[ DEFAULT_NAME_ACCESS_COUNT ];
|
||
|
||
sal_Int32 iIndex = getIndexForName( aName );
|
||
if( iIndex != -1 )
|
||
{
|
||
if( !pNameAccessTab[iIndex].is() )
|
||
{
|
||
ImplIntroTest* p = new ImplIntroTest( mxMgr );
|
||
OUString aName2( OUString::createFromAscii("IntroTest by Name-Access, Index = ") );
|
||
aName2 += OUString::valueOf( iIndex );
|
||
//aName2 = aName2 + StringToUString( String( iIndex ), CHARSET_SYSTEM );
|
||
p->setObjectName( aName2 );
|
||
pNameAccessTab[iIndex] = p;
|
||
}
|
||
|
||
Reference< XIntroTest > xRet = pNameAccessTab[iIndex];
|
||
aRetAny = makeAny( xRet );
|
||
|
||
//aRetAny.set( &xRet, XIntroTest_getReflection() );
|
||
//return (UsrObject*)(XIntroTest*)pNameAccessTab[iIndex];
|
||
}
|
||
return aRetAny;
|
||
}
|
||
|
||
Sequence< OUString > ImplIntroTest::getElementNames( )
|
||
throw(RuntimeException)
|
||
//Sequence<UString> ImplIntroTest::getElementNames(void) const THROWS( (UsrSystemException) )
|
||
{
|
||
Sequence<OUString> aStrSeq( DEFAULT_NAME_ACCESS_COUNT );
|
||
OUString* pStr = aStrSeq.getArray();
|
||
for( sal_Int32 i = 0 ; i < DEFAULT_NAME_ACCESS_COUNT ; i++ )
|
||
{
|
||
OUString aName( OUString::createFromAscii("Item") );
|
||
aName += OUString::valueOf( i );
|
||
//aName = aName + StringToUString( i, CHARSET_SYSTEM );
|
||
pStr[i] = aName;
|
||
}
|
||
return aStrSeq;
|
||
}
|
||
|
||
sal_Bool ImplIntroTest::hasByName( const OUString& aName )
|
||
throw(RuntimeException)
|
||
//BOOL ImplIntroTest::hasByName(const UString& Name) const THROWS( (UsrSystemException) )
|
||
{
|
||
return ( getIndexForName( aName ) != -1 );
|
||
}
|
||
|
||
// XIndexAccess-Methoden
|
||
sal_Int32 ImplIntroTest::getCount( )
|
||
throw(RuntimeException)
|
||
//sal_Int32 ImplIntroTest::getCount(void) const THROWS( (UsrSystemException) )
|
||
{
|
||
return iIndexAccessCount;
|
||
}
|
||
|
||
Any ImplIntroTest::getByIndex( sal_Int32 Index )
|
||
throw(IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
|
||
//Any ImplIntroTest::getByIndex( sal_Int32 Index ) const
|
||
//THROWS( (IndexOutOfBoundsException, WrappedTargetException, UsrSystemException) )
|
||
{
|
||
Any aRetAny;
|
||
|
||
if( !pIndexAccessTab )
|
||
((ImplIntroTest*)this)->pIndexAccessTab = new Reference< XIntroTest >[ iIndexAccessCount ];
|
||
|
||
if( Index < iIndexAccessCount )
|
||
{
|
||
if( !pNameAccessTab[Index].is() )
|
||
{
|
||
ImplIntroTest* p = new ImplIntroTest( mxMgr );
|
||
OUString aName( OUString::createFromAscii("IntroTest by Index-Access, Index = ") );
|
||
aName += OUString::valueOf( Index );
|
||
//aName = aName + StringToUString( String( iIndex ), CHARSET_SYSTEM );
|
||
p->setObjectName( aName );
|
||
pIndexAccessTab[Index] = p;
|
||
}
|
||
Reference< XIntroTest > xRet = pIndexAccessTab[Index];
|
||
aRetAny = makeAny( xRet );
|
||
}
|
||
return aRetAny;
|
||
}
|
||
|
||
void ImplIntroTest::addPropertiesChangeListener( const Sequence< OUString >& /*PropertyNames*/,
|
||
const Reference< XPropertiesChangeListener >& /*Listener*/ )
|
||
throw(RuntimeException)
|
||
//void ImplIntroTest::addPropertiesChangeListener
|
||
//(const Sequence< UString >& PropertyNames, const XPropertiesChangeListenerRef& Listener)
|
||
//THROWS( (UsrSystemException) )
|
||
{
|
||
}
|
||
|
||
void ImplIntroTest::removePropertiesChangeListener
|
||
( const Reference< XPropertiesChangeListener >& /*Listener*/ )
|
||
throw(RuntimeException)
|
||
//void ImplIntroTest::removePropertiesChangeListener(const XPropertiesChangeListenerRef& Listener)
|
||
//THROWS( (UsrSystemException) )
|
||
{
|
||
}
|
||
|
||
|
||
|
||
struct DefItem
|
||
{
|
||
char const * pName;
|
||
sal_Int32 nConcept;
|
||
};
|
||
|
||
// Spezial-Wert fuer Method-Concept, um "normale" Funktionen kennzeichnen zu koennen
|
||
#define MethodConcept_NORMAL_IMPL 0x80000000
|
||
|
||
|
||
// Test-Objekt liefern
|
||
Any getIntrospectionTestObject( const Reference< XMultiServiceFactory > & xMgr )
|
||
{
|
||
Any aObjAny;
|
||
Reference< XIntroTest > xTestObj = new ImplIntroTest( xMgr );
|
||
aObjAny.setValue( &xTestObj, ::getCppuType( (const Reference< XIntroTest > *)0 ) );
|
||
return aObjAny;
|
||
}
|
||
|
||
static sal_Bool test_introsp( Reference< XMultiServiceFactory > xMgr,
|
||
Reference< XIdlReflection > /*xRefl*/, Reference< XIntrospection > xIntrospection )
|
||
{
|
||
DefItem pPropertyDefs[] =
|
||
{
|
||
{ "Factor", PropertyConcept::PROPERTYSET },
|
||
{ "MyCount", PropertyConcept::PROPERTYSET },
|
||
{ "Info", PropertyConcept::PROPERTYSET },
|
||
{ "ObjectName", PropertyConcept::ATTRIBUTES },
|
||
{ "FirstName", PropertyConcept::ATTRIBUTES },
|
||
{ "LastName", PropertyConcept::ATTRIBUTES },
|
||
{ "Age", PropertyConcept::ATTRIBUTES },
|
||
{ "ChildrenCount", PropertyConcept::ATTRIBUTES },
|
||
{ "FirstStruct", PropertyConcept::ATTRIBUTES },
|
||
{ "SecondStruct", PropertyConcept::ATTRIBUTES },
|
||
{ "Droenk", PropertyConcept::METHODS },
|
||
{ "IntroTest", PropertyConcept::METHODS },
|
||
{ "Bla", PropertyConcept::METHODS },
|
||
{ "Blub", PropertyConcept::METHODS },
|
||
{ "Gulp", PropertyConcept::METHODS },
|
||
{ "Strings", PropertyConcept::METHODS },
|
||
{ "MultiSequence", PropertyConcept::METHODS },
|
||
{ "PropertySetInfo", PropertyConcept::METHODS },
|
||
{ "ElementType", PropertyConcept::METHODS },
|
||
{ "ElementNames", PropertyConcept::METHODS },
|
||
{ "Count", PropertyConcept::METHODS },
|
||
{ "Types", PropertyConcept::METHODS },
|
||
{ "ImplementationId", PropertyConcept::METHODS },
|
||
{ NULL, 0 }
|
||
};
|
||
|
||
// Tabelle der Property-Namen, die gefunden werden muessen
|
||
// char* pDemandedPropNames[] =
|
||
// {
|
||
// "Factor",
|
||
// "MyCount",
|
||
// "Info",
|
||
// "ObjectName",
|
||
// "FirstName",
|
||
// "LastName",
|
||
// "Age",
|
||
// "ChildrenCount",
|
||
// "FirstStruct",
|
||
// "SecondStruct",
|
||
// "Droenk",
|
||
// "IntroTest",
|
||
// "Bla",
|
||
// "Blub",
|
||
// "Gulp",
|
||
// "Strings",
|
||
// "MultiSequence",
|
||
// "PropertySetInfo",
|
||
// "ElementType",
|
||
// "ElementNames",
|
||
// "Count",
|
||
// "Types"
|
||
// "ImplementationId"
|
||
// };
|
||
|
||
char const * pDemandedPropVals[] =
|
||
{
|
||
"3.140000",
|
||
"42",
|
||
"Hallo",
|
||
"IntroTest-Obj Nr. 0",
|
||
"Markus",
|
||
"Meyer",
|
||
"33",
|
||
"2",
|
||
"TYPE STRUCT",
|
||
"TYPE STRUCT",
|
||
"314",
|
||
"TYPE INTERFACE",
|
||
"42",
|
||
"111",
|
||
"99",
|
||
"TYPE SEQUENCE",
|
||
"TYPE SEQUENCE",
|
||
"TYPE INTERFACE",
|
||
"TYPE TYPE",
|
||
"TYPE SEQUENCE",
|
||
"10",
|
||
"TYPE SEQUENCE",
|
||
"TYPE SEQUENCE",
|
||
};
|
||
|
||
char const * pDemandedModifiedPropVals[] =
|
||
{
|
||
"4.140000",
|
||
"43",
|
||
"Hallo (Modified!)",
|
||
"IntroTest-Obj Nr. 0 (Modified!)",
|
||
"Markus",
|
||
"Meyer",
|
||
"33",
|
||
"3",
|
||
"Wert wurde nicht modifiziert",
|
||
"Wert wurde nicht modifiziert",
|
||
"315",
|
||
"Wert wurde nicht modifiziert",
|
||
"42",
|
||
"112",
|
||
"99",
|
||
"Wert wurde nicht modifiziert",
|
||
"Wert wurde nicht modifiziert",
|
||
"Wert wurde nicht modifiziert",
|
||
"Wert wurde nicht modifiziert",
|
||
"Wert wurde nicht modifiziert",
|
||
"10",
|
||
"Wert wurde nicht modifiziert"
|
||
"Wert wurde nicht modifiziert"
|
||
};
|
||
|
||
char const * pDemandedPropTypes[] =
|
||
{
|
||
"double",
|
||
"long",
|
||
"string",
|
||
"string",
|
||
"string",
|
||
"string",
|
||
"short",
|
||
"short",
|
||
"com.sun.star.beans.Property",
|
||
"com.sun.star.beans.PropertyValue",
|
||
"long",
|
||
"ModuleA.XIntroTest",
|
||
"short",
|
||
"short",
|
||
"short",
|
||
"[]string",
|
||
"[][][]short",
|
||
"com.sun.star.beans.XPropertySetInfo",
|
||
"type",
|
||
"[]string",
|
||
"long",
|
||
"[]type",
|
||
"[]byte",
|
||
};
|
||
//is() nDemandedPropCount = 22;
|
||
|
||
|
||
DefItem pMethodDefs[] =
|
||
{
|
||
{ "queryInterface", MethodConcept_NORMAL_IMPL },
|
||
{ "acquire", MethodConcept::DANGEROUS },
|
||
{ "release", MethodConcept::DANGEROUS },
|
||
{ "writeln", MethodConcept_NORMAL_IMPL },
|
||
{ "getDroenk", MethodConcept::PROPERTY },
|
||
{ "getIntroTest", MethodConcept::PROPERTY },
|
||
{ "getUps", MethodConcept_NORMAL_IMPL },
|
||
{ "setDroenk", MethodConcept::PROPERTY },
|
||
{ "getBla", MethodConcept::PROPERTY },
|
||
{ "setBla", MethodConcept_NORMAL_IMPL },
|
||
{ "getBlub", MethodConcept::PROPERTY },
|
||
{ "setBlub", MethodConcept::PROPERTY },
|
||
{ "getGulp", MethodConcept::PROPERTY },
|
||
{ "setGulp", MethodConcept_NORMAL_IMPL },
|
||
{ "getTypeClass", MethodConcept_NORMAL_IMPL },
|
||
{ "setTypeClass", MethodConcept_NORMAL_IMPL },
|
||
{ "getStrings", MethodConcept::PROPERTY },
|
||
{ "setStrings", MethodConcept::PROPERTY },
|
||
{ "setStringsPerMethod", MethodConcept_NORMAL_IMPL },
|
||
{ "getMultiSequence", MethodConcept::PROPERTY },
|
||
{ "setMultiSequence", MethodConcept::PROPERTY },
|
||
{ "addPropertiesChangeListener", MethodConcept::LISTENER },
|
||
{ "removePropertiesChangeListener", MethodConcept::LISTENER },
|
||
{ "getPropertySetInfo", MethodConcept::PROPERTY },
|
||
{ "setPropertyValue", MethodConcept_NORMAL_IMPL },
|
||
{ "getPropertyValue", MethodConcept_NORMAL_IMPL },
|
||
{ "addPropertyChangeListener", MethodConcept::LISTENER },
|
||
{ "removePropertyChangeListener", MethodConcept::LISTENER },
|
||
{ "addVetoableChangeListener", MethodConcept::LISTENER },
|
||
{ "removeVetoableChangeListener", MethodConcept::LISTENER },
|
||
{ "getElementType", MethodConcept::PROPERTY | MethodConcept::NAMECONTAINER| MethodConcept::INDEXCONTAINER | MethodConcept::ENUMERATION },
|
||
{ "hasElements", MethodConcept::NAMECONTAINER | MethodConcept::INDEXCONTAINER | MethodConcept::ENUMERATION },
|
||
{ "getByName", MethodConcept::NAMECONTAINER },
|
||
{ "getElementNames", MethodConcept::PROPERTY | MethodConcept::NAMECONTAINER },
|
||
{ "hasByName", MethodConcept::NAMECONTAINER },
|
||
{ "getCount", MethodConcept::PROPERTY | MethodConcept::INDEXCONTAINER },
|
||
{ "getByIndex", MethodConcept::INDEXCONTAINER },
|
||
{ "getTypes", MethodConcept::PROPERTY },
|
||
{ "getImplementationId", MethodConcept::PROPERTY },
|
||
{ "queryAdapter", MethodConcept_NORMAL_IMPL },
|
||
{ NULL, 0 }
|
||
};
|
||
|
||
OString aErrorStr;
|
||
|
||
//******************************************************
|
||
|
||
// Test-Objekt anlegen
|
||
Any aObjAny = getIntrospectionTestObject( xMgr );
|
||
|
||
// Introspection-Service holen
|
||
//Reference< XMultiServiceFactory > xServiceManager(getProcessServiceManager(), USR_QUERY);
|
||
//Reference< XIntrospection > xIntrospection( xMgr->createInstance(L"com.sun.star.beans.Introspection"), UNO_QUERY );
|
||
//TEST_ENSHURE( xIntrospection.is(), "Creation of introspection instance failed" );
|
||
//if( !xIntrospection.is() )
|
||
//return sal_False;
|
||
|
||
// und unspecten
|
||
Reference< XIntrospectionAccess > xAccess = xIntrospection->inspect( aObjAny );
|
||
xAccess = xIntrospection->inspect( aObjAny );
|
||
xAccess = xIntrospection->inspect( aObjAny );
|
||
TEST_ENSHURE( xAccess.is(), "introspection failed, no XIntrospectionAccess returned" );
|
||
if( !xAccess.is() )
|
||
return sal_False;
|
||
|
||
// Ergebnis der Introspection pruefen
|
||
|
||
// XPropertySet-UIK ermitteln
|
||
Type aType = getCppuType( (Reference< XPropertySet >*) NULL );
|
||
//typelib_InterfaceTypeDescription* pTypeDesc = NULL;
|
||
//aType.getDescription( (typelib_TypeDescription**)&pTypeDesc );
|
||
//Uik aPropertySetUik = *(Uik*)&pTypeDesc->aUik;
|
||
//typelib_typedescription_release( (typelib_TypeDescription*)pTypeDesc );
|
||
|
||
Reference< XInterface > xPropSetIface = xAccess->queryAdapter( aType );
|
||
//Reference< XInterface > xPropSetIface = xAccess->queryAdapter( aPropertySetUik );
|
||
Reference< XPropertySet > xPropSet( xPropSetIface, UNO_QUERY );
|
||
//XPropertySetRef xPropSet = (XPropertySet*)xPropSetIface->
|
||
// queryInterface( XPropertySet::getSmartUik() );
|
||
TEST_ENSHURE( xPropSet.is(), "Could not get XPropertySet by queryAdapter()" );
|
||
|
||
// XExactName
|
||
Reference< XExactName > xExactName( xAccess, UNO_QUERY );
|
||
TEST_ENSHURE( xExactName.is(), "Introspection unterstuetzt kein ExactName" );
|
||
|
||
// Schleife ueber alle Kombinationen von Concepts
|
||
for( sal_Int32 nConcepts = 0 ; nConcepts < 16 ; nConcepts++ )
|
||
{
|
||
//printf( "*******************************************************\n" );
|
||
//printf( "nConcepts = %ld\n", nConcepts );
|
||
|
||
// Wieviele Properties sollten es sein
|
||
sal_Int32 nDemandedPropCount = 0;
|
||
sal_Int32 iList = 0;
|
||
while( pPropertyDefs[ iList ].pName )
|
||
{
|
||
if( pPropertyDefs[ iList ].nConcept & nConcepts )
|
||
nDemandedPropCount++;
|
||
iList++;
|
||
}
|
||
|
||
if( xPropSet.is() )
|
||
{
|
||
Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();
|
||
//Sequence<Property> aRetSeq = xPropSetInfo->getProperties();
|
||
Sequence<Property> aRetSeq = xAccess->getProperties( nConcepts );
|
||
|
||
sal_Int32 nLen = aRetSeq.getLength();
|
||
|
||
aErrorStr = "Expected to find ";
|
||
aErrorStr += OString::valueOf( nDemandedPropCount );
|
||
aErrorStr += " properties but found ";
|
||
aErrorStr += OString::valueOf( nLen );
|
||
TEST_ENSHURE( nLen == nDemandedPropCount, aErrorStr.getStr() );
|
||
|
||
// cout << "**********************************\n";
|
||
// cout << "*** Ergebnis der Introspection ***\n";
|
||
// cout << "**********************************\n";
|
||
// cout << "\nIntrospection hat " << nLen << " Properties gefunden:\n";
|
||
|
||
const Property* pProps = aRetSeq.getConstArray();
|
||
Any aPropVal;
|
||
sal_Int32 i;
|
||
iList = 0;
|
||
for( i = 0 ; i < nLen ; i++ )
|
||
{
|
||
const Property aProp = pProps[ i ];
|
||
|
||
// Naechste Passende Methode in der Liste suchen
|
||
while( pPropertyDefs[ iList ].pName )
|
||
{
|
||
if( pPropertyDefs[ iList ].nConcept & nConcepts )
|
||
break;
|
||
iList++;
|
||
}
|
||
sal_Int32 iDemanded = iList;
|
||
iList++;
|
||
|
||
OUString aPropName = aProp.Name;
|
||
OString aNameStr( aPropName.getStr(), aPropName.getLength(), RTL_TEXTENCODING_ASCII_US );
|
||
//UStringToString(aPropName, CHARSET_SYSTEM);
|
||
|
||
//printf( "Property = %s\n", aNameStr.getStr() );
|
||
|
||
OString aDemandedName = pPropertyDefs[ iDemanded ].pName;
|
||
//OString aDemandedName = pDemandedPropNames[ i ];
|
||
aErrorStr = "Expected property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", found \"";
|
||
aErrorStr += aNameStr;
|
||
aErrorStr += "\"";
|
||
TEST_ENSHURE( aNameStr == aDemandedName, aErrorStr.getStr() );
|
||
// cout << "Property " << (i+1) << ": \"" << (const char*)UStringToString(aPropName, CHARSET_SYSTEM) << "\"";
|
||
|
||
|
||
Type aPropType = aProp.Type;
|
||
OString aTypeNameStr( OUStringToOString(aPropType.getTypeName(), RTL_TEXTENCODING_ASCII_US) );
|
||
//Reference< XIdlClass > xPropType = aProp.Type;
|
||
//OString aTypeNameStr( xPropType->getName(), xPropType->getName().getLength(), RTL_TEXTENCODING_ASCII_US );
|
||
OString aDemandedTypeNameStr = pDemandedPropTypes[ iDemanded ];
|
||
//OString aDemandedTypeNameStr = pDemandedPropTypes[ i ];
|
||
aErrorStr = "Property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", expected type >";
|
||
aErrorStr += aDemandedTypeNameStr;
|
||
aErrorStr += "< found type >";
|
||
aErrorStr += aTypeNameStr;
|
||
aErrorStr += "<";
|
||
TEST_ENSHURE( aTypeNameStr == aDemandedTypeNameStr, aErrorStr.getStr() );
|
||
// cout << " (Prop-Typ: " << (const char*)UStringToString(xPropType->getName(), CHARSET_SYSTEM) << ")";
|
||
|
||
// Wert des Property lesen und ausgeben
|
||
aPropVal = xPropSet->getPropertyValue( aPropName );
|
||
// cout << "\n\tWert = " << (const char*)UStringToString(AnyToString( aPropVal, sal_True ), CHARSET_SYSTEM);
|
||
|
||
OString aValStr = OUStringToOString( AnyToString( aPropVal, sal_False, xMgr ), RTL_TEXTENCODING_ASCII_US );
|
||
OString aDemandedValStr = pDemandedPropVals[ iDemanded ];
|
||
//OString aDemandedValStr = pDemandedPropVals[ i ];
|
||
aErrorStr = "Property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", expected val >";
|
||
aErrorStr += aDemandedValStr;
|
||
aErrorStr += "< found val >";
|
||
aErrorStr += aValStr;
|
||
aErrorStr += "<";
|
||
TEST_ENSHURE( aValStr == aDemandedValStr, aErrorStr.getStr() );
|
||
|
||
// Wert pruefen und typgerecht modifizieren
|
||
TypeClass eType = aPropVal.getValueType().getTypeClass();
|
||
//Reference< XIdlClass > xIdlClass = aPropVal.getReflection()->getIdlClass();
|
||
//TypeClass eType = xIdlClass->getTypeClass();
|
||
Any aNewVal;
|
||
sal_Bool bModify = sal_True;
|
||
switch( eType )
|
||
{
|
||
case TypeClass_STRING:
|
||
{
|
||
OUString aStr;
|
||
aPropVal >>= aStr;
|
||
//OString aStr = aPropVal.getString();
|
||
aStr = aStr + OUString::createFromAscii(" (Modified!)");
|
||
aNewVal <<= aStr;
|
||
break;
|
||
}
|
||
case TypeClass_DOUBLE:
|
||
{
|
||
double d;
|
||
aPropVal >>= d;
|
||
aNewVal <<= d + 1.0;
|
||
break;
|
||
}
|
||
case TypeClass_SHORT:
|
||
{
|
||
sal_Int16 n;
|
||
aPropVal >>= n;
|
||
aNewVal <<= sal_Int16( n + 1 );
|
||
break;
|
||
}
|
||
case TypeClass_LONG:
|
||
{
|
||
sal_Int32 n;
|
||
aPropVal >>= n;
|
||
aNewVal <<= sal_Int32( n + 1 );
|
||
break;
|
||
}
|
||
default:
|
||
bModify = sal_False;
|
||
break;
|
||
}
|
||
|
||
// Modifizieren nur beim letzten Durchlauf
|
||
if( nConcepts == 15 )
|
||
{
|
||
// XExactName pruefen, dafuer alles gross machen
|
||
// (Introspection ist mit LowerCase implementiert, also anders machen)
|
||
OUString aUpperUStr = aPropName.toAsciiUpperCase();
|
||
OUString aExactName = xExactName->getExactName( aUpperUStr );
|
||
if( aExactName != aPropName )
|
||
{
|
||
aErrorStr = "Property \"";
|
||
aErrorStr += OUStringToOString( aPropName, RTL_TEXTENCODING_ASCII_US );
|
||
aErrorStr += "\", not found as \"";
|
||
aErrorStr += OUStringToOString(aUpperUStr, RTL_TEXTENCODING_ASCII_US );
|
||
aErrorStr += "\" using XExactName";
|
||
TEST_ENSHURE( sal_False, aErrorStr.getStr() );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
bModify = sal_False;
|
||
}
|
||
|
||
// Neuen Wert setzen, wieder lesen und ausgeben
|
||
if( bModify )
|
||
{
|
||
// cout.flush();
|
||
|
||
// 1.7.1999, UnknownPropertyException bei ReadOnly-Properties abfangen
|
||
try
|
||
{
|
||
xPropSet->setPropertyValue( aPropName, aNewVal );
|
||
}
|
||
catch(UnknownPropertyException e1)
|
||
{
|
||
}
|
||
|
||
aPropVal = xPropSet->getPropertyValue( aPropName );
|
||
// cout << "\n\tModifizierter Wert = " << (const char*) UStringToString(AnyToString( aPropVal, sal_True ), CHARSET_SYSTEM) << "\n";
|
||
|
||
OUString aStr = AnyToString( aPropVal, sal_False, xMgr );
|
||
OString aModifiedValStr = OUStringToOString( aStr, RTL_TEXTENCODING_ASCII_US );
|
||
OString aDemandedModifiedValStr = pDemandedModifiedPropVals[ i ];
|
||
aErrorStr = "Property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", expected modified val >";
|
||
aErrorStr += aDemandedModifiedValStr;
|
||
aErrorStr += "< found val >";
|
||
aErrorStr += aModifiedValStr;
|
||
aErrorStr += "<";
|
||
TEST_ENSHURE( aModifiedValStr == aDemandedModifiedValStr, aErrorStr.getStr() );
|
||
}
|
||
else
|
||
{
|
||
// cout << "\n\tWert wurde nicht modifiziert\n";
|
||
}
|
||
|
||
// Checken, ob alle Properties auch einzeln gefunden werden
|
||
aErrorStr = "property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\" not found with hasProperty()";
|
||
OUString aWDemandedName = OStringToOUString(aDemandedName, RTL_TEXTENCODING_ASCII_US );
|
||
sal_Bool bProperty = xAccess->hasProperty( aWDemandedName, nConcepts );
|
||
//sal_Bool bProperty = xAccess->hasProperty( aWDemandedName, PropertyConcept::ALL - PropertyConcept::DANGEROUS );
|
||
TEST_ENSHURE( bProperty, aErrorStr.getStr() );
|
||
|
||
aErrorStr = "property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\" not equal to same Property in sequence returned by getProperties()";
|
||
try
|
||
{
|
||
Property aGetProp = xAccess->getProperty( aWDemandedName, nConcepts );
|
||
//Property aGetProp = xAccess->getProperty( aWDemandedName, PropertyConcept::ALL );
|
||
//TEST_ENSHURE( aGetProp == aProp , aErrorStr.getStr() );
|
||
}
|
||
catch (RuntimeException e1)
|
||
{
|
||
aErrorStr = "property \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", exception was thrown when trying getProperty()";
|
||
TEST_ENSHURE( sal_False, aErrorStr.getStr() );
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
// Schleife ueber alle Kombinationen von Concepts
|
||
for( sal_Int32 nConcepts = 0 ; nConcepts < 128 ; nConcepts++ )
|
||
{
|
||
//printf( "*******************************************************\n" );
|
||
//printf( "nConcepts = %ld\n", nConcepts );
|
||
|
||
// Das 2^6-Bit steht fuer "den Rest"
|
||
sal_Int32 nRealConcepts = nConcepts;
|
||
if( nConcepts & 0x40 )
|
||
nRealConcepts |= (0xFFFFFFFF - 0x3F);
|
||
|
||
// Wieviele Methoden sollten es sein
|
||
sal_Int32 nDemandedMethCount = 0;
|
||
sal_Int32 iList = 0;
|
||
while( pMethodDefs[ iList ].pName )
|
||
{
|
||
if( pMethodDefs[ iList ].nConcept & nRealConcepts )
|
||
nDemandedMethCount++;
|
||
iList++;
|
||
}
|
||
|
||
// Methoden-Array ausgeben
|
||
//aMethodSeq = xAccess->getMethods
|
||
Sequence< Reference< XIdlMethod > > aMethodSeq = xAccess->getMethods( nRealConcepts );
|
||
//Sequence<XIdlMethodRef> aMethodSeq = xAccess->getMethods
|
||
// ( MethodConcept::ALL - MethodConcept::DANGEROUS - MethodConcept::PROPERTY );
|
||
sal_Int32 nLen = aMethodSeq.getLength();
|
||
// cout << "\n\n*** Methoden ***\n";
|
||
// cout << "Introspection hat " << nLen << " Methoden gefunden:\n";
|
||
|
||
aErrorStr = "Expected to find ";
|
||
aErrorStr += OString::valueOf( nDemandedMethCount );
|
||
aErrorStr += " methods but found ";
|
||
aErrorStr += OString::valueOf( nLen );
|
||
TEST_ENSHURE( nLen == nDemandedMethCount, aErrorStr.getStr() );
|
||
|
||
const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray();
|
||
sal_Int32 i;
|
||
iList = 0;
|
||
|
||
for( i = 0 ; i < nLen ; i++ )
|
||
{
|
||
// Methode ansprechen
|
||
const Reference< XIdlMethod >& rxMethod = pMethods[i];
|
||
|
||
// Methode ausgeben
|
||
OUString aMethName = rxMethod->getName();
|
||
OString aNameStr = OUStringToOString(aMethName, RTL_TEXTENCODING_ASCII_US );
|
||
|
||
//printf( "Method = %s\n", aNameStr.getStr() );
|
||
|
||
// Naechste Passende Methode in der Liste suchen
|
||
while( pMethodDefs[ iList ].pName )
|
||
{
|
||
if( pMethodDefs[ iList ].nConcept & nRealConcepts )
|
||
break;
|
||
iList++;
|
||
}
|
||
OString aDemandedName = pMethodDefs[ iList ].pName;
|
||
iList++;
|
||
|
||
//OString aDemandedName = pDemandedMethNames[ i ];
|
||
aErrorStr = "Expected method \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", found \"";
|
||
aErrorStr += aNameStr;
|
||
aErrorStr += "\"";
|
||
TEST_ENSHURE( aNameStr == aDemandedName, aErrorStr.getStr() );
|
||
// cout << "Methode " << (i+1) << ": " << (const char*) UStringToString(rxMethod->getReturnType()->getName(), CHARSET_SYSTEM)
|
||
// << " " << (const char*) UStringToString(rxMethod->getName(), CHARSET_SYSTEM) << "( ";
|
||
|
||
// Checken, ob alle Methoden auch einzeln gefunden werden
|
||
aErrorStr = "method \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\" not found with hasMethod()";
|
||
OUString aWDemandedName = OStringToOUString(aDemandedName, RTL_TEXTENCODING_ASCII_US );
|
||
sal_Bool bMethod = xAccess->hasMethod( aWDemandedName, nRealConcepts );
|
||
//sal_Bool bMethod = xAccess->hasMethod( aWDemandedName, MethodConcept::ALL );
|
||
TEST_ENSHURE( bMethod, aErrorStr.getStr() );
|
||
|
||
aErrorStr = "method \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\" not equal to same method in sequence returned by getMethods()";
|
||
try
|
||
{
|
||
Reference< XIdlMethod > xGetMethod = xAccess->getMethod( aWDemandedName, nRealConcepts );
|
||
//XIdlMethodRef xGetMethod = xAccess->getMethod( aWDemandedName, MethodConcept::ALL );
|
||
TEST_ENSHURE( xGetMethod == rxMethod , aErrorStr.getStr() );
|
||
}
|
||
catch (RuntimeException e1)
|
||
{
|
||
aErrorStr = "method \"";
|
||
aErrorStr += aDemandedName;
|
||
aErrorStr += "\", exception was thrown when trying getMethod()";
|
||
TEST_ENSHURE( sal_False, aErrorStr.getStr() );
|
||
}
|
||
}
|
||
}
|
||
|
||
// Listener-Klassen ausgeben
|
||
Sequence< Type > aClassSeq = xAccess->getSupportedListeners();
|
||
sal_Int32 nLen = aClassSeq.getLength();
|
||
// cout << "\n\n*** Anmeldbare Listener ***\n";
|
||
// cout << "Introspection hat " << nLen << " Listener gefunden:\n";
|
||
|
||
const Type* pListeners = aClassSeq.getConstArray();
|
||
for( sal_Int32 i = 0 ; i < nLen ; i++ )
|
||
{
|
||
// Methode ansprechen
|
||
const Type& aListenerType = pListeners[i];
|
||
|
||
// Namen besorgen
|
||
OUString aListenerClassName = aListenerType.getTypeName();
|
||
// cout << "Listener " << (i+1) << ": " << (const char*)UStringToString(aListenerClassName, CHARSET_SYSTEM) << "\n";
|
||
}
|
||
|
||
|
||
// Performance bei hasMethod testen.
|
||
//CheckMethodPerformance( xAccess, "queryInterface", 100000 );
|
||
//CheckMethodPerformance( xAccess, "getIdlClasses", 100000 );
|
||
|
||
// cout.flush();
|
||
|
||
|
||
|
||
|
||
return sal_True;
|
||
}
|
||
|
||
|
||
SAL_IMPLEMENT_MAIN()
|
||
{
|
||
Reference< XMultiServiceFactory > xMgr( createRegistryServiceFactory( OUString::createFromAscii("stoctest.rdb") ) );
|
||
|
||
sal_Bool bSucc = sal_False;
|
||
try
|
||
{
|
||
Reference< XImplementationRegistration > xImplReg(
|
||
xMgr->createInstance( OUString::createFromAscii("com.sun.star.registry.ImplementationRegistration") ), UNO_QUERY );
|
||
OSL_ENSURE( xImplReg.is(), "### no impl reg!" );
|
||
|
||
// Register services
|
||
OUString libName( RTL_CONSTASCII_USTRINGPARAM(
|
||
"reflection.uno" SAL_DLLEXTENSION) );
|
||
// ORealDynamicLoader::computeLibraryName( OUString::createFromAscii("corefl"), libName);
|
||
fprintf(stderr, "1\n" );
|
||
xImplReg->registerImplementation(OUString::createFromAscii("com.sun.star.loader.SharedLibrary"),
|
||
libName, Reference< XSimpleRegistry >() );
|
||
fprintf(stderr, "2\n" );
|
||
Reference< XIdlReflection > xRefl( xMgr->createInstance( OUString::createFromAscii("com.sun.star.reflection.CoreReflection") ), UNO_QUERY );
|
||
OSL_ENSURE( xRefl.is(), "### no corereflection!" );
|
||
|
||
// Introspection
|
||
libName = OUString::createFromAscii(
|
||
"introspection.uno" SAL_DLLEXTENSION);
|
||
// ORealDynamicLoader::computeLibraryName( OUString::createFromAscii("insp"), libName);
|
||
fprintf(stderr, "3\n" );
|
||
xImplReg->registerImplementation(OUString::createFromAscii("com.sun.star.loader.SharedLibrary"),
|
||
libName, Reference< XSimpleRegistry >() );
|
||
fprintf(stderr, "4\n" );
|
||
Reference< XIntrospection > xIntrosp( xMgr->createInstance( OUString::createFromAscii("com.sun.star.beans.Introspection") ), UNO_QUERY );
|
||
OSL_ENSURE( xRefl.is(), "### no corereflection!" );
|
||
|
||
fprintf(stderr, "before test_introsp\n" );
|
||
bSucc = test_introsp( xMgr, xRefl, xIntrosp );
|
||
fprintf(stderr, "after test_introsp\n" );
|
||
//bSucc = test_corefl( xRefl );
|
||
}
|
||
catch (Exception & rExc)
|
||
{
|
||
OSL_ENSURE( sal_False, "### exception occured!" );
|
||
OString aMsg( OUStringToOString( rExc.Message, RTL_TEXTENCODING_ASCII_US ) );
|
||
OSL_TRACE( "### exception occured: " );
|
||
OSL_TRACE( aMsg.getStr() );
|
||
OSL_TRACE( "\n" );
|
||
}
|
||
|
||
Reference< XComponent >( xMgr, UNO_QUERY )->dispose();
|
||
|
||
printf( "testintrosp %s !\n", (bSucc ? "succeeded" : "failed") );
|
||
return (bSucc ? 0 : -1);
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//*****************************
|
||
//*** TEST-Implementationen ***
|
||
//*****************************
|
||
// Bleibt auf Dauer nicht drin, dient als exportierbare Test-Klasse
|
||
// z.B. fuer Basic-Anbindung
|
||
|
||
|
||
|
||
|
||
|
||
|