new, c implemented test component

1 files changed, 833 insertions, 0 deletions

diff --git a/cppu/test/test_cuno.c b/cppu/test/test_cuno.c
new file mode 100644
index 000000000..b963da5ad
--- /dev/null
+++ b/cppu/test/test_cuno.c
@@ -0,0 +1,833 @@
+/*************************************************************************
+ *
+ *  $RCSfile: test_cuno.c,v $
+ *
+ *  $Revision: 1.1 $
+ *
+ *  last change: $Author: jsc $ $Date: 2001-04-23 10:20:01 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 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
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+
+#include <stdio.h>
+#include <osl/diagnose.h>
+#include <osl/time.h>
+#include <osl/interlck.h>
+#include <rtl/alloc.h>
+//
+/*
+#include <uno/dispatcher.h>
+#include <uno/environment.h>
+#include <uno/mapping.hxx>
+*/
+#include <uno/data.h>
+#include <uno/any2.h>
+#include <uno/sequence2.h>
+
+#include <test/XLanguageBindingTest.h>
+
+
+typedef struct _InstanceData
+{
+    void const * m_XInterface[2];
+    void const * m_XLBTestBase[2];
+    void const * m_XLanguageBindingTest[2];
+    
+    sal_Int32				 m_refCount;
+    typelib_TypeDescription* m_pTDXInterface;
+    typelib_TypeDescription* m_pTDSeqTestElement;
+    typelib_TypeDescription* m_pTDTestDataElements;
+    test_TestDataElements 	 m_data, m_structData;
+} InstanceData;
+
+#define GET_THIS( p ) (InstanceData *)((void **)p)[1]
+
+//==================================================================================================
+static void SAL_CALL c_acquire( void * p )
+    SAL_THROW_EXTERN_C( )
+{
+    CUNO_CALL( ((com_sun_star_uno_XInterface *)p) )->acquire( (com_sun_star_uno_XInterface *)p );
+}
+//==================================================================================================
+static  void SAL_CALL c_release( void * p )
+    SAL_THROW_EXTERN_C( )
+{
+    CUNO_CALL( ((com_sun_star_uno_XInterface *)p) )->release( (com_sun_star_uno_XInterface *)p );
+}
+//==================================================================================================
+static void * SAL_CALL c_queryInterface( void * p, typelib_TypeDescriptionReference * pType )
+    SAL_THROW_EXTERN_C( )
+{
+    uno_Any aExc;
+    com_sun_star_uno_XInterface * pRet = NULL;
+
+    if (CUNO_EXCEPTION_OCCURED( CUNO_CALL( ((com_sun_star_uno_XInterface *)p) )->queryInterface( (com_sun_star_uno_XInterface *)p, &aExc, &pRet, pType ) ))
+    {
+        uno_any_destruct( &aExc, c_release );
+        return NULL;
+    }
+    else
+    {
+        return pRet;
+    }
+}	
+
+void defaultConstructData(test_TestDataElements* pData, typelib_TypeDescriptionReference * pElemType)
+{
+    pData->_Base._Base.Bool = sal_False;
+    pData->_Base._Base.Char = 0;
+    pData->_Base._Base.Byte = 0;
+    pData->_Base._Base.Short = 0;
+    pData->_Base._Base.UShort = 0;
+    pData->_Base._Base.Long = 0;
+    pData->_Base._Base.ULong = 0;
+    pData->_Base._Base.Hyper = 0;
+    pData->_Base._Base.UHyper = 0;
+    pData->_Base._Base.Float = 0;
+    pData->_Base._Base.Double = 0;
+    pData->_Base._Base.Enum = test_TestEnum_TEST;
+    pData->_Base.String = 0;
+    rtl_uString_new(&pData->_Base.String);
+    pData->_Base.Interface = 0;
+    uno_any_construct(&pData->_Base.Any, 0, 0, 0);
+/*	pData->Sequence = 0; */
+    uno_type_sequence_construct(
+        &pData->Sequence, pElemType, 0, 0, c_acquire );
+}	
+
+void assign1( test_TestSimple* rData,
+             sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
+             sal_Int16 nShort, sal_uInt16 nUShort,
+             sal_Int32 nLong, sal_uInt32 nULong,
+             sal_Int64 nHyper, sal_uInt64 nUHyper,
+             float fFloat, double fDouble,
+             test_TestEnum eEnum)
+{
+    rData->Bool = bBool;
+    rData->Char = cChar;
+    rData->Byte = nByte;
+    rData->Short = nShort;
+    rData->UShort = nUShort;
+    rData->Long = nLong;
+    rData->ULong = nULong;
+    rData->Hyper = nHyper;
+    rData->UHyper = nUHyper;
+    rData->Float = fFloat;
+    rData->Double = fDouble;
+    rData->Enum = eEnum;
+}
+
+void assign2( test_TestElement* rData,
+             sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
+             sal_Int16 nShort, sal_uInt16 nUShort,
+             sal_Int32 nLong, sal_uInt32 nULong,
+             sal_Int64 nHyper, sal_uInt64 nUHyper,
+             float fFloat, double fDouble,
+             test_TestEnum eEnum, rtl_uString* rStr,
+             com_sun_star_uno_XInterface* xTest,
+             uno_Any* rAny,
+             typelib_TypeDescription* pTDIface)
+{
+    assign1( (test_TestSimple *)rData,
+            bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
+            eEnum );
+    rtl_uString_assign(&rData->String, rStr);
+/*	uno_assignData(&rData->Interface, pTDIface, &xTest, pTDIface, c_queryInterface, c_acquire, c_release); */
+    if ( rData->Interface )
+         CUNO_CALL(rData->Interface)->release(rData->Interface);
+
+    if ( xTest )
+    {
+        CUNO_CALL(xTest)->acquire(xTest);
+        rData->Interface = xTest;
+    } else
+    {
+        rData->Interface = 0;
+    }
+
+    uno_type_any_assign(&rData->Any, rAny->pData, rAny->pType, c_acquire, c_release);
+}
+
+void assign3( test_TestDataElements* rData,
+             sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
+             sal_Int16 nShort, sal_uInt16 nUShort,
+             sal_Int32 nLong, sal_uInt32 nULong,
+             sal_Int64 nHyper, sal_uInt64 nUHyper,
+             float fFloat, double fDouble,
+             test_TestEnum eEnum, rtl_uString* rStr,
+             com_sun_star_uno_XInterface* xTest,
+             uno_Any* rAny,
+             /* sequence< test_TestElement >*/uno_Sequence* rSequence,
+             typelib_TypeDescription* pTDIface,
+             typelib_TypeDescription* pTDSeqElem)
+{
+    assign2( (test_TestElement *)rData,
+            bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
+            eEnum,rStr, xTest, rAny, pTDIface );
+    uno_sequence_assign(&rData->Sequence, rSequence, pTDSeqElem, c_release);
+}
+
+/* XInterface =============================================================================== */
+
+/* XInterface::acquire */
+cuno_ErrorCode SAL_CALL XInterface_acquire( com_sun_star_uno_XInterface* pIFace)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    osl_incrementInterlockedCount( &pImpl->m_refCount );
+    return CUNO_ERROR_NONE;
+}
+
+/* XInterface::release */
+cuno_ErrorCode SAL_CALL XInterface_release( com_sun_star_uno_XInterface * pIFace )
+{ 
+    InstanceData * pImpl = GET_THIS( pIFace );
+    if( osl_decrementInterlockedCount( &pImpl->m_refCount ) == 0)
+    {
+        uno_destructData(&pImpl->m_data, pImpl->m_pTDTestDataElements, c_release);
+        uno_destructData(&pImpl->m_structData, pImpl->m_pTDTestDataElements, c_release);
+        typelib_typedescription_release(pImpl->m_pTDXInterface);
+        typelib_typedescription_release(pImpl->m_pTDSeqTestElement);
+        typelib_typedescription_release(pImpl->m_pTDTestDataElements);
+        rtl_freeMemory( pImpl );
+    }
+    return CUNO_ERROR_NONE;
+}
+
+/* XInterface::queryInterface */
+cuno_ErrorCode SAL_CALL XInterface_queryInterface( com_sun_star_uno_XInterface * pIFace, uno_Any * pExc, com_sun_star_uno_XInterface ** pRet, typelib_TypeDescriptionReference * pTypeRef)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    com_sun_star_uno_XInterface * pIFaceRet = 0;
+    sal_Char* sXInterface= "com.sun.star.uno.XInterface";
+    sal_Char* sXLBTestBase= "test.XLBTestBase";
+    sal_Char* sXLanguageBindingTest= "test.XLanguageBindingTest";
+    rtl_uString* usXInterface= 0;
+    rtl_uString* usXLBTestBase= 0;
+    rtl_uString* usXLanguageBindingTest= 0;
+
+    if ( pTypeRef )
+    {
+        rtl_uString_newFromAscii( &usXInterface, sXInterface);
+        rtl_uString_newFromAscii( &usXLBTestBase, sXLBTestBase);
+        rtl_uString_newFromAscii( &usXLanguageBindingTest, sXLanguageBindingTest);
+
+        if( ! rtl_ustr_compare_WithLength( usXInterface->buffer, usXInterface->length,
+                                           pTypeRef->pTypeName->buffer, pTypeRef->pTypeName->length ) )
+               pIFaceRet = (com_sun_star_uno_XInterface *)&pImpl->m_XInterface;
+        else if( !rtl_ustr_compare_WithLength( usXLBTestBase->buffer, usXLBTestBase->length,
+                                               pTypeRef->pTypeName->buffer, pTypeRef->pTypeName->length ) )
+               pIFaceRet = (com_sun_star_uno_XInterface *)&pImpl->m_XLBTestBase;
+        else if( !rtl_ustr_compare_WithLength( usXLanguageBindingTest->buffer, usXLanguageBindingTest->length,
+                                               pTypeRef->pTypeName->buffer, pTypeRef->pTypeName->length ) )
+               pIFaceRet = (com_sun_star_uno_XInterface *)&pImpl->m_XLanguageBindingTest;
+
+        if( pIFaceRet )
+        {
+            CUNO_CALL(pIFaceRet)->acquire( pIFaceRet );
+            *pRet = pIFaceRet;
+        } else
+        {
+            *pRet = 0;
+        }
+
+        rtl_uString_release( usXInterface);
+        rtl_uString_release( usXLBTestBase);
+        rtl_uString_release( usXLanguageBindingTest); 
+    }
+    return CUNO_ERROR_NONE;
+}
+
+/* XLBTestBase =============================================================================== */
+
+/* XLBTestBase::getBool */
+cuno_ErrorCode SAL_CALL XLBTestBase_getBool( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Bool *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Bool;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setBool */
+cuno_ErrorCode SAL_CALL XLBTestBase_setBool( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Bool value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Bool = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getByte */
+cuno_ErrorCode SAL_CALL XLBTestBase_getByte( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int8 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Byte;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setByte */
+cuno_ErrorCode SAL_CALL XLBTestBase_setByte( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int8 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Byte = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getChar */
+cuno_ErrorCode SAL_CALL XLBTestBase_getChar( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Unicode *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Char;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setChar */
+cuno_ErrorCode SAL_CALL XLBTestBase_setChar( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Unicode value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Char = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getShort */
+cuno_ErrorCode SAL_CALL XLBTestBase_getShort( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int16 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Short;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setShort */
+cuno_ErrorCode SAL_CALL XLBTestBase_setShort( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int16 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Short = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getUShort */
+cuno_ErrorCode SAL_CALL XLBTestBase_getUShort( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt16 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.UShort;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setUShort */
+cuno_ErrorCode SAL_CALL XLBTestBase_setUShort( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt16 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.UShort = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getLong */
+cuno_ErrorCode SAL_CALL XLBTestBase_getLong( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int32 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Long;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setLong */
+cuno_ErrorCode SAL_CALL XLBTestBase_setLong( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int32 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Long = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getULong */
+cuno_ErrorCode SAL_CALL XLBTestBase_getULong( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt32 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.ULong;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setULong */
+cuno_ErrorCode SAL_CALL XLBTestBase_setULong( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt32 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.ULong = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getHyper */
+cuno_ErrorCode SAL_CALL XLBTestBase_getHyper( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int64 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Hyper;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setHyper */
+cuno_ErrorCode SAL_CALL XLBTestBase_setHyper( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Int64 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Hyper = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getUHyper */
+cuno_ErrorCode SAL_CALL XLBTestBase_getUHyper( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt64 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.UHyper;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setUHyper */
+cuno_ErrorCode SAL_CALL XLBTestBase_setUHyper( test_XLBTestBase * pIFace, uno_Any * pExc, sal_uInt64 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.UHyper = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getFloat */
+cuno_ErrorCode SAL_CALL XLBTestBase_getFloat( test_XLBTestBase * pIFace, uno_Any * pExc, float *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Float;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setFloat */
+cuno_ErrorCode SAL_CALL XLBTestBase_setFloat( test_XLBTestBase * pIFace, uno_Any * pExc, float value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Float = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getDouble */
+cuno_ErrorCode SAL_CALL XLBTestBase_getDouble( test_XLBTestBase * pIFace, uno_Any * pExc, double *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Double;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setDouble */
+cuno_ErrorCode SAL_CALL XLBTestBase_setDouble( test_XLBTestBase * pIFace, uno_Any * pExc, double value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Double = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getEnum */
+cuno_ErrorCode SAL_CALL XLBTestBase_getEnum( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestEnum *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = pImpl->m_data._Base._Base.Enum;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setEnum */
+cuno_ErrorCode SAL_CALL XLBTestBase_setEnum( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestEnum value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    pImpl->m_data._Base._Base.Enum = value;
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getString */
+cuno_ErrorCode SAL_CALL XLBTestBase_getString( test_XLBTestBase * pIFace, uno_Any * pExc, rtl_uString **pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *pRet = 0;
+    rtl_uString_newFromString(pRet, pImpl->m_data._Base.String);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setString */
+cuno_ErrorCode SAL_CALL XLBTestBase_setString( test_XLBTestBase * pIFace, uno_Any * pExc, rtl_uString *value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    rtl_uString_assign(&pImpl->m_data._Base.String, value);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getInterface */
+cuno_ErrorCode SAL_CALL XLBTestBase_getInterface( test_XLBTestBase * pIFace, uno_Any * pExc, com_sun_star_uno_XInterface **pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+/*	uno_copyData(pRet, &pImpl->m_data._Base.Interface, pImpl->m_pTDXInterface, c_acquire); */
+    if ( pImpl->m_data._Base.Interface )
+    {
+        CUNO_CALL(pImpl->m_data._Base.Interface)->acquire(pImpl->m_data._Base.Interface);
+        *pRet = pImpl->m_data._Base.Interface;
+    } else
+    {
+        *pRet = 0;
+    }
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setInterface */
+cuno_ErrorCode SAL_CALL XLBTestBase_setInterface( test_XLBTestBase * pIFace, uno_Any * pExc, com_sun_star_uno_XInterface *value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+/*	uno_assignData(&pImpl->m_data._Base.Interface, pImpl->m_pTDXInterface, &value, pImpl->m_pTDXInterface, c_queryInterface, c_acquire, c_release); */
+    if ( pImpl->m_data._Base.Interface )
+         CUNO_CALL(pImpl->m_data._Base.Interface)->release(pImpl->m_data._Base.Interface);
+
+    if ( value )
+    {
+        CUNO_CALL(value)->acquire(value);
+        pImpl->m_data._Base.Interface = value;
+    } else
+    {
+        pImpl->m_data._Base.Interface = 0;
+    }
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getAny */
+cuno_ErrorCode SAL_CALL XLBTestBase_getAny( test_XLBTestBase * pIFace, uno_Any * pExc, uno_Any *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    typelib_TypeDescription* pTD = 0;
+    typelib_typedescriptionreference_getDescription(&pTD, pImpl->m_data._Base.Any.pType);
+    uno_any_construct(pRet, pImpl->m_data._Base.Any.pData, pTD, c_acquire);
+    typelib_typedescription_release(pTD);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setAny */
+cuno_ErrorCode SAL_CALL XLBTestBase_setAny( test_XLBTestBase * pIFace, uno_Any * pExc, uno_Any *value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    typelib_TypeDescription* pTD = 0;
+    typelib_typedescriptionreference_getDescription(&pTD, value->pType);
+    uno_any_assign(&pImpl->m_data._Base.Any, value->pData, pTD, c_acquire, c_release);
+    typelib_typedescription_release(pTD);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getSequence */
+cuno_ErrorCode SAL_CALL XLBTestBase_getSequence( test_XLBTestBase * pIFace, uno_Any * pExc, /*sequence< test.TestElement >*/uno_Sequence **pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    uno_sequence_construct(pRet, pImpl->m_pTDSeqTestElement, pImpl->m_data.Sequence->elements, pImpl->m_data.Sequence->nElements, c_acquire); 
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setSequence */
+cuno_ErrorCode SAL_CALL XLBTestBase_setSequence( test_XLBTestBase * pIFace, uno_Any * pExc, /*sequence< test.TestElement >*/uno_Sequence *value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    uno_sequence_assign(&pImpl->m_data.Sequence, value, pImpl->m_pTDSeqTestElement, c_release);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getStruct */
+cuno_ErrorCode SAL_CALL XLBTestBase_getStruct( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestDataElements *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    uno_copyData(pRet, &pImpl->m_structData, pImpl->m_pTDTestDataElements, c_acquire);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setStruct */
+cuno_ErrorCode SAL_CALL XLBTestBase_setStruct( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestDataElements *value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    uno_assignData(&pImpl->m_structData, pImpl->m_pTDTestDataElements, value, pImpl->m_pTDTestDataElements, c_queryInterface, c_acquire, c_release);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setValues */
+cuno_ErrorCode SAL_CALL XLBTestBase_setValues( test_XLBTestBase * pIFace, uno_Any * pExc, sal_Bool aBool, sal_Unicode aChar, sal_Int8 aByte, sal_Int16 aShort, sal_uInt16 aUShort, sal_Int32 aLong, sal_uInt32 aULong, sal_Int64 aHyper, sal_uInt64 aUHyper, float aFloat, double aDouble, test_TestEnum aEnum, rtl_uString* aString, com_sun_star_uno_XInterface *aInterface, uno_Any * aAny, /*sequence< test.TestElement >*/ uno_Sequence * aSequence, test_TestDataElements *aStruct)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    assign3(&pImpl->m_data, aBool, aChar, aByte, aShort, aUShort, aLong, aULong, aHyper, aUHyper, aFloat, aDouble,
+            aEnum, aString, aInterface, aAny,aSequence, pImpl->m_pTDXInterface, pImpl->m_pTDSeqTestElement);
+    uno_assignData(&pImpl->m_structData, pImpl->m_pTDTestDataElements, aStruct, pImpl->m_pTDTestDataElements, c_queryInterface, c_acquire, c_release);	
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::setValues2 */
+cuno_ErrorCode SAL_CALL XLBTestBase_setValues2( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestDataElements* pRet, sal_Bool* aBool, sal_Unicode* aChar, sal_Int8* aByte, sal_Int16* aShort, sal_uInt16* aUShort, sal_Int32* aLong, sal_uInt32* aULong, sal_Int64* aHyper, sal_uInt64* aUHyper, float* aFloat, double* aDouble, test_TestEnum* aEnum, rtl_uString** aString, com_sun_star_uno_XInterface **aInterface, uno_Any * aAny, /*sequence< test.TestElement >*/ uno_Sequence ** aSequence, test_TestDataElements * aStruct)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    assign3(&pImpl->m_data, *aBool, *aChar, *aByte, *aShort, *aUShort, *aLong, *aULong, *aHyper, *aUHyper, *aFloat, *aDouble,
+            *aEnum, *aString, *aInterface, aAny, *aSequence, pImpl->m_pTDXInterface, pImpl->m_pTDSeqTestElement);
+    uno_assignData(&pImpl->m_structData, pImpl->m_pTDTestDataElements, aStruct, pImpl->m_pTDTestDataElements, c_queryInterface, c_acquire, c_release);	
+    uno_copyData(pRet, &pImpl->m_structData, pImpl->m_pTDTestDataElements, c_acquire);
+    return CUNO_ERROR_NONE;	
+}	
+/* XLBTestBase::getValues */
+cuno_ErrorCode SAL_CALL XLBTestBase_getValues( test_XLBTestBase * pIFace, uno_Any * pExc, test_TestDataElements* pRet, sal_Bool* aBool, sal_Unicode* aChar, sal_Int8* aByte, sal_Int16* aShort, sal_uInt16* aUShort, sal_Int32* aLong, sal_uInt32* aULong, sal_Int64* aHyper, sal_uInt64* aUHyper, float* aFloat, double* aDouble, test_TestEnum* aEnum, rtl_uString** aString, com_sun_star_uno_XInterface **aInterface, uno_Any * aAny, /*sequence< test.TestElement >*/ uno_Sequence ** aSequence, test_TestDataElements * aStruct)
+{
+    typelib_TypeDescription* pTD = 0;
+    InstanceData * pImpl = GET_THIS( pIFace );
+    *aBool = pImpl->m_data._Base._Base.Bool;
+    *aChar = pImpl->m_data._Base._Base.Char;
+    *aByte = pImpl->m_data._Base._Base.Byte;
+    *aShort = pImpl->m_data._Base._Base.Short;
+    *aUShort = pImpl->m_data._Base._Base.UShort;
+    *aLong = pImpl->m_data._Base._Base.Long;
+    *aULong = pImpl->m_data._Base._Base.ULong;
+    *aHyper = pImpl->m_data._Base._Base.Hyper;
+    *aUHyper = pImpl->m_data._Base._Base.UHyper;
+    *aFloat = pImpl->m_data._Base._Base.Float;
+    *aDouble = pImpl->m_data._Base._Base.Double;
+    *aEnum = pImpl->m_data._Base._Base.Enum;
+    *aString = 0;
+    rtl_uString_newFromString(aString, pImpl->m_data._Base.String);
+/*	uno_copyData(aInterface, &pImpl->m_data._Base.Interface, pImpl->m_pTDXInterface, c_acquire); */
+    if ( pImpl->m_data._Base.Interface )
+    {
+        CUNO_CALL(pImpl->m_data._Base.Interface)->acquire(pImpl->m_data._Base.Interface);
+        *aInterface = pImpl->m_data._Base.Interface;
+    } else
+    {
+        *aInterface = 0;
+    }
+    typelib_typedescriptionreference_getDescription(&pTD, pImpl->m_data._Base.Any.pType);
+    uno_any_construct(aAny, pImpl->m_data._Base.Any.pData, pTD, c_acquire);
+    typelib_typedescription_release(pTD);
+    uno_sequence_construct(aSequence, pImpl->m_pTDSeqTestElement, pImpl->m_data.Sequence->elements, pImpl->m_data.Sequence->nElements, c_acquire); 
+    uno_copyData(aStruct, &pImpl->m_structData, pImpl->m_pTDTestDataElements, c_acquire);
+    uno_copyData(pRet, &pImpl->m_structData, pImpl->m_pTDTestDataElements, c_acquire);
+    return CUNO_ERROR_NONE;	
+}	
+
+/* XLanguageBindingTest =============================================================================== */
+
+/* XLanguageBindingTest::getRuntimeException */
+cuno_ErrorCode SAL_CALL XLanguageBindingTest_getRuntimeException( test_XLanguageBindingTest * pIFace, uno_Any * pExc, sal_Int32 *pRet)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    com_sun_star_uno_RuntimeException aExc;
+    typelib_TypeDescription * pTD = 0;
+    rtl_uString * pTypeName = 0;
+    uno_Any excp;
+
+    rtl_uString_newFromAscii( &pTypeName, "com.sun.star.uno.RuntimeException");
+    typelib_typedescription_getByName(&pTD, pTypeName);
+
+    aExc._Base.Message = 0;
+    rtl_uString_newFromAscii(&aExc._Base.Message, "dum dum dum ich tanz im kreis herum...");
+    aExc._Base.Context = 0;
+    if (CUNO_EXCEPTION_OCCURED( CUNO_CALL(pIFace)->getInterface( (test_XLBTestBase *)pIFace, &excp, &aExc._Base.Context) ))
+    {
+        /* ... */
+        uno_any_destruct( &excp, 0 );
+    }
+
+    uno_any_construct(pExc, &aExc, pTD, c_acquire);
+    uno_destructData(&aExc, pTD, c_release);
+    typelib_typedescription_release(pTD);
+    rtl_uString_release(pTypeName);
+
+    return CUNO_ERROR_EXCEPTION;	
+}	
+/* XLanguageBindingTest::setRuntimeException */
+cuno_ErrorCode SAL_CALL XLanguageBindingTest_setRuntimeException( test_XLanguageBindingTest * pIFace, uno_Any * pExc, sal_Int32 value)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    com_sun_star_uno_RuntimeException aExc;
+    typelib_TypeDescription * pTD = 0;
+    rtl_uString * pTypeName = 0;
+    uno_Any excp;
+
+    rtl_uString_newFromAscii( &pTypeName, "com.sun.star.uno.RuntimeException");
+    typelib_typedescription_getByName(&pTD, pTypeName);
+
+    aExc._Base.Message = 0;
+    rtl_uString_newFromAscii(&aExc._Base.Message, "dum dum dum ich tanz im kreis herum...");
+    aExc._Base.Context = 0;
+    if (CUNO_EXCEPTION_OCCURED( CUNO_CALL(pIFace)->getInterface( (test_XLBTestBase *)pIFace, &excp, &aExc._Base.Context) ))
+    {
+        /* ... */
+        uno_any_destruct( &excp, 0 );
+    }
+
+    uno_any_construct(pExc, &aExc, pTD, c_acquire);
+    uno_destructData(&aExc, pTD, c_release);
+    typelib_typedescription_release(pTD);
+    rtl_uString_release(pTypeName);
+
+    return CUNO_ERROR_EXCEPTION;	
+}	
+/* XLanguageBindingTest::raiseException */
+cuno_ErrorCode SAL_CALL XLanguageBindingTest_raiseException( test_XLanguageBindingTest * pIFace, uno_Any * pExc, test_TestDataElements* pRet, sal_Bool* aBool, sal_Unicode* aChar, sal_Int8* aByte, sal_Int16* aShort, sal_uInt16* aUShort, sal_Int32* aLong, sal_uInt32* aULong, sal_Int64* aHyper, sal_uInt64* aUHyper, float* aFloat, double* aDouble, test_TestEnum* aEnum, rtl_uString ** aString, com_sun_star_uno_XInterface ** aInterface, uno_Any* aAny, /*sequence< test.TestElement >*/ uno_Sequence ** aSequence, test_TestDataElements* AStruct)
+{
+    InstanceData * pImpl = GET_THIS( pIFace );
+    com_sun_star_lang_IllegalArgumentException aExc;
+    typelib_TypeDescription * pTD = 0;
+    rtl_uString * pTypeName = 0;
+    uno_Any excp;
+
+    rtl_uString_newFromAscii( &pTypeName, "com.sun.star.lang.IllegalArgumentException");
+    typelib_typedescription_getByName(&pTD, pTypeName);
+
+    aExc.ArgumentPosition = 5;
+    aExc._Base.Message = 0;
+    rtl_uString_newFromAscii(&aExc._Base.Message, "dum dum dum ich tanz im kreis herum...");
+    aExc._Base.Context = 0;
+    if (CUNO_EXCEPTION_OCCURED( CUNO_CALL(pIFace)->getInterface( (test_XLBTestBase *)pIFace, &excp, &aExc._Base.Context) ))
+    {
+        /* ... */
+        uno_any_destruct( &excp, 0 );
+    }
+
+    uno_any_construct(pExc, &aExc, pTD, c_acquire);
+    uno_destructData(&aExc, pTD, c_release);
+    typelib_typedescription_release(pTD);
+    rtl_uString_release(pTypeName);
+
+    return CUNO_ERROR_EXCEPTION;	
+}	
+
+
+static const com_sun_star_uno_XInterface_ftab s_XInterface_ftab={
+                           XInterface_queryInterface, 
+                           XInterface_acquire, 
+                           XInterface_release, 
+                          };
+static const test_XLBTestBase_ftab s_XLBTestBase_ftab={
+                           XInterface_queryInterface, 
+                           XInterface_acquire, 
+                           XInterface_release,
+                           XLBTestBase_getBool,
+                           XLBTestBase_setBool,
+                           XLBTestBase_getByte,
+                           XLBTestBase_setByte,
+                           XLBTestBase_getChar,
+                           XLBTestBase_setChar,
+                           XLBTestBase_getShort,
+                           XLBTestBase_setShort,
+                           XLBTestBase_getUShort,
+                           XLBTestBase_setUShort,
+                           XLBTestBase_getLong,
+                           XLBTestBase_setLong,
+                           XLBTestBase_getULong,
+                           XLBTestBase_setULong,
+                           XLBTestBase_getHyper,
+                           XLBTestBase_setHyper,
+                           XLBTestBase_getUHyper,
+                           XLBTestBase_setUHyper,
+                           XLBTestBase_getFloat,
+                           XLBTestBase_setFloat,
+                           XLBTestBase_getDouble,
+                           XLBTestBase_setDouble,
+                           XLBTestBase_getEnum,
+                           XLBTestBase_setEnum,
+                           XLBTestBase_getString,
+                           XLBTestBase_setString,
+                           XLBTestBase_getInterface,
+                           XLBTestBase_setInterface,
+                           XLBTestBase_getAny,
+                           XLBTestBase_setAny,
+                           XLBTestBase_getSequence,
+                           XLBTestBase_setSequence,
+                           XLBTestBase_getStruct,
+                           XLBTestBase_setStruct,
+                           XLBTestBase_setValues,
+                           XLBTestBase_setValues2,
+                           XLBTestBase_getValues
+                          };
+static const test_XLanguageBindingTest_ftab s_XLanguageBindingTest_ftab={
+                           XInterface_queryInterface,
+                           XInterface_acquire,
+                           XInterface_release,
+                           XLBTestBase_getBool,
+                           XLBTestBase_setBool,
+                           XLBTestBase_getByte,
+                           XLBTestBase_setByte,
+                           XLBTestBase_getChar,
+                           XLBTestBase_setChar,
+                           XLBTestBase_getShort,
+                           XLBTestBase_setShort,
+                           XLBTestBase_getUShort,
+                           XLBTestBase_setUShort,
+                           XLBTestBase_getLong,
+                           XLBTestBase_setLong,
+                           XLBTestBase_getULong,
+                           XLBTestBase_setULong,
+                           XLBTestBase_getHyper,
+                           XLBTestBase_setHyper,
+                           XLBTestBase_getUHyper,
+                           XLBTestBase_setUHyper,
+                           XLBTestBase_getFloat,
+                           XLBTestBase_setFloat,
+                           XLBTestBase_getDouble,
+                           XLBTestBase_setDouble,
+                           XLBTestBase_getEnum,
+                           XLBTestBase_setEnum,
+                           XLBTestBase_getString,
+                           XLBTestBase_setString,
+                           XLBTestBase_getInterface,
+                           XLBTestBase_setInterface,
+                           XLBTestBase_getAny,
+                           XLBTestBase_setAny,
+                           XLBTestBase_getSequence,
+                           XLBTestBase_setSequence,
+                           XLBTestBase_getStruct,
+                           XLBTestBase_setStruct,
+                           XLBTestBase_setValues,
+                           XLBTestBase_setValues2,
+                           XLBTestBase_getValues,
+                           XLanguageBindingTest_getRuntimeException,
+                           XLanguageBindingTest_setRuntimeException,
+                           XLanguageBindingTest_raiseException
+                          };
+
+com_sun_star_uno_XInterface* SAL_CALL createTestObject()
+{
+    InstanceData *pObj;
+    rtl_uString* usXInterface = 0;
+    rtl_uString* usSeqTestElement = 0;
+    rtl_uString* usTestDataElements = 0;
+
+    /* Create a data instance of the component */
+    pObj= (InstanceData*)rtl_allocateMemory( sizeof( InstanceData) );
+    pObj->m_XInterface[0] = &s_XInterface_ftab;
+    pObj->m_XInterface[1] = pObj;
+    pObj->m_XLBTestBase[0] = &s_XLBTestBase_ftab;
+    pObj->m_XLBTestBase[1] = pObj;
+    pObj->m_XLanguageBindingTest[0] = &s_XLanguageBindingTest_ftab;
+    pObj->m_XLanguageBindingTest[1] = pObj;
+
+    /* Initalize the reference counter member and other component data */
+    pObj->m_refCount= 1;
+
+    pObj->m_pTDXInterface = 0;
+    rtl_uString_newFromAscii( &usXInterface, "com.sun.star.uno.XInterface");
+    typelib_typedescription_getByName(&pObj->m_pTDXInterface, usXInterface);
+
+    pObj->m_pTDSeqTestElement = 0;
+    rtl_uString_newFromAscii( &usSeqTestElement, "[]test.TestElement");
+    typelib_typedescription_getByName(&pObj->m_pTDSeqTestElement, usSeqTestElement);
+
+    pObj->m_pTDTestDataElements = 0;
+    rtl_uString_newFromAscii( &usTestDataElements, "test.TestDataElements");
+    typelib_typedescription_getByName(&pObj->m_pTDTestDataElements, usTestDataElements);
+
+    defaultConstructData(&pObj->m_data, pObj->m_pTDSeqTestElement->pWeakRef);
+    defaultConstructData(&pObj->m_structData, pObj->m_pTDSeqTestElement->pWeakRef);
+
+    rtl_uString_release(usXInterface);
+    rtl_uString_release(usSeqTestElement);
+    rtl_uString_release(usTestDataElements);
+    return (com_sun_star_uno_XInterface *)&pObj->m_XInterface;	
+}	
+