summaryrefslogtreecommitdiffstats
path: root/testtools/com/sun/star/comp/bridge/TestComponent.java
diff options
context:
space:
mode:
Diffstat (limited to 'testtools/com/sun/star/comp/bridge/TestComponent.java')
-rw-r--r--testtools/com/sun/star/comp/bridge/TestComponent.java1342
1 files changed, 1342 insertions, 0 deletions
diff --git a/testtools/com/sun/star/comp/bridge/TestComponent.java b/testtools/com/sun/star/comp/bridge/TestComponent.java
new file mode 100644
index 000000000..7d59de570
--- /dev/null
+++ b/testtools/com/sun/star/comp/bridge/TestComponent.java
@@ -0,0 +1,1342 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 .
+ */
+
+package com.sun.star.comp.bridge;
+
+import com.sun.star.comp.loader.FactoryHelper;
+
+import com.sun.star.lang.XServiceInfo;
+import com.sun.star.lang.XTypeProvider;
+
+import com.sun.star.test.performance.ComplexTypes;
+import com.sun.star.test.performance.XPerformanceTest;
+
+import test.testtools.bridgetest.BadConstructorArguments;
+import test.testtools.bridgetest.Constructors;
+import test.testtools.bridgetest.Constructors2;
+import test.testtools.bridgetest.TestDataElements;
+import test.testtools.bridgetest.TestElement;
+import test.testtools.bridgetest.TestEnum;
+import test.testtools.bridgetest.TestPolyStruct;
+import test.testtools.bridgetest.TestPolyStruct2;
+import test.testtools.bridgetest.TestStruct;
+import test.testtools.bridgetest.SmallStruct;
+import test.testtools.bridgetest.MediumStruct;
+import test.testtools.bridgetest.BigStruct;
+import test.testtools.bridgetest.TwoFloats;
+import test.testtools.bridgetest.FourFloats;
+import test.testtools.bridgetest.MixedFloatAndInteger;
+import test.testtools.bridgetest.ThreeByteStruct;
+import test.testtools.bridgetest.XBridgeTest;
+import test.testtools.bridgetest.XBridgeTest2;
+import test.testtools.bridgetest.XCurrentContextChecker;
+import test.testtools.bridgetest.XMulti;
+import test.testtools.bridgetest.XRecursiveCall;
+
+
+import com.sun.star.lang.IllegalArgumentException;
+import com.sun.star.lang.XMultiServiceFactory;
+import com.sun.star.lang.XSingleServiceFactory;
+
+import com.sun.star.registry.XRegistryKey;
+
+import com.sun.star.uno.Any;
+import com.sun.star.uno.Type;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.uno.XInterface;
+
+@SuppressWarnings("unchecked")
+public class TestComponent {
+ public static final boolean DEBUG = false;
+
+ public static class _PerformancTestObject implements XPerformanceTest, XServiceInfo, XTypeProvider {
+ private static final String __serviceName = "com.sun.star.comp.benchmark.JavaTestObject";
+
+ private int _long;
+ private long _hyper;
+ private float _float;
+ private double _double;
+ private String _string = "";
+ private Object _xInterface;
+ private Object _any;
+ private Object _interface_sequence[] = new Object[0];
+ private ComplexTypes _complexTypes = new ComplexTypes();
+
+ // Attributes
+ public int getLong_attr() throws com.sun.star.uno.RuntimeException {
+ return _long;
+ }
+
+ public void setLong_attr( int _long_attr ) throws com.sun.star.uno.RuntimeException {
+ _long = _long_attr;
+ }
+
+ public long getHyper_attr() throws com.sun.star.uno.RuntimeException {
+ return _hyper;
+ }
+
+ public void setHyper_attr( long _hyper_attr ) throws com.sun.star.uno.RuntimeException {
+ _hyper = _hyper_attr;
+ }
+
+ public float getFloat_attr() throws com.sun.star.uno.RuntimeException {
+ return _float;
+ }
+
+ public void setFloat_attr( float _float_attr ) throws com.sun.star.uno.RuntimeException {
+ _float = _float_attr;
+ }
+
+ public double getDouble_attr() throws com.sun.star.uno.RuntimeException {
+ return _double;
+ }
+
+ public void setDouble_attr( double _double_attr ) throws com.sun.star.uno.RuntimeException {
+ _double = _double_attr;
+ }
+
+ public String getString_attr() throws com.sun.star.uno.RuntimeException {
+ return _string;
+ }
+
+ public void setString_attr( String _string_attr ) throws com.sun.star.uno.RuntimeException {
+ _string = _string_attr;
+ }
+
+ public Object getInterface_attr() throws com.sun.star.uno.RuntimeException {
+ return _xInterface;
+ }
+
+ public void setInterface_attr( java.lang.Object _interface_attr ) throws com.sun.star.uno.RuntimeException {
+ _xInterface = _interface_attr;
+ }
+
+ public Object getAny_attr() throws com.sun.star.uno.RuntimeException {
+ return _any;
+ }
+
+ public void setAny_attr(Object _any_attr ) throws com.sun.star.uno.RuntimeException {
+ _any = _any_attr;
+ }
+
+ public Object[] getSequence_attr() throws com.sun.star.uno.RuntimeException {
+ return _interface_sequence;
+ }
+
+ public void setSequence_attr(Object[] _sequence_attr ) throws com.sun.star.uno.RuntimeException {
+ _interface_sequence = _sequence_attr;
+ }
+
+ public ComplexTypes getStruct_attr() throws com.sun.star.uno.RuntimeException {
+ return _complexTypes;
+ }
+
+ public void setStruct_attr( ComplexTypes _struct_attr ) throws com.sun.star.uno.RuntimeException {
+ _complexTypes = _struct_attr;
+ }
+
+
+ // Methods
+ public void async() throws com.sun.star.uno.RuntimeException {
+ }
+
+ public void sync( ) throws com.sun.star.uno.RuntimeException {
+ }
+
+ public ComplexTypes complex_in( /*IN*/ComplexTypes aVal ) throws com.sun.star.uno.RuntimeException {
+ return aVal;
+ }
+
+ public ComplexTypes complex_inout( /*INOUT*/ComplexTypes[] aVal ) throws com.sun.star.uno.RuntimeException {
+ return aVal[0];
+ }
+
+ public void complex_oneway( /*IN*/ComplexTypes aVal ) throws com.sun.star.uno.RuntimeException {
+ }
+
+ public void complex_noreturn( /*IN*/ComplexTypes aVal ) throws com.sun.star.uno.RuntimeException {
+ }
+
+ public XPerformanceTest createObject( ) throws com.sun.star.uno.RuntimeException {
+ return new _PerformancTestObject();
+ }
+
+ public int getLong() throws com.sun.star.uno.RuntimeException {
+ return _long;
+ }
+
+ public void setLong(/*IN*/int n) throws com.sun.star.uno.RuntimeException {
+ _long = n;
+ }
+
+ public long getHyper() throws com.sun.star.uno.RuntimeException {
+ return _hyper;
+ }
+
+ public void setHyper(/*IN*/long n) throws com.sun.star.uno.RuntimeException {
+ _hyper = n;
+ }
+
+ public float getFloat() throws com.sun.star.uno.RuntimeException {
+ return _float;
+ }
+
+ public void setFloat( /*IN*/float f ) throws com.sun.star.uno.RuntimeException {
+ _float = f;
+ }
+
+ public double getDouble( ) throws com.sun.star.uno.RuntimeException {
+ return _double;
+ }
+
+ public void setDouble( /*IN*/double f ) throws com.sun.star.uno.RuntimeException {
+ _double = f;
+ }
+
+ public String getString( ) throws com.sun.star.uno.RuntimeException {
+ return _string;
+ }
+
+ public void setString( /*IN*/String s ) throws com.sun.star.uno.RuntimeException {
+ _string = s;
+ }
+
+ public Object getInterface( ) throws com.sun.star.uno.RuntimeException {
+ return _xInterface;
+ }
+
+ public void setInterface( /*IN*/Object x ) throws com.sun.star.uno.RuntimeException {
+ _xInterface = x;
+ }
+
+ public Object getAny( ) throws com.sun.star.uno.RuntimeException {
+ return _any;
+ }
+
+ public void setAny( /*IN*/java.lang.Object a ) throws com.sun.star.uno.RuntimeException {
+ _any = a;
+ }
+
+ public Object[] getSequence( ) throws com.sun.star.uno.RuntimeException {
+ return _interface_sequence;
+ }
+
+ public void setSequence( /*IN*/Object[] seq ) throws com.sun.star.uno.RuntimeException {
+ if(DEBUG) System.err.println("#### " + getClass().getName() + ".setSequence:" + seq);
+
+ _interface_sequence = seq;
+ }
+
+ public ComplexTypes getStruct( ) throws com.sun.star.uno.RuntimeException {
+ return _complexTypes;
+ }
+
+ public void setStruct( /*IN*/ComplexTypes c ) throws com.sun.star.uno.RuntimeException {
+ _complexTypes = c;
+ }
+
+ public void raiseRuntimeException( ) throws com.sun.star.uno.RuntimeException {
+ throw new com.sun.star.uno.RuntimeException();
+ }
+
+ // XServiceInfo
+ public String getImplementationName() throws com.sun.star.uno.RuntimeException {
+ return __serviceName;
+ }
+
+ public boolean supportsService(String rServiceName) throws com.sun.star.uno.RuntimeException {
+ String rSNL[] = getSupportedServiceNames();
+
+ for(int nPos = rSNL.length; (nPos--) != 0;) {
+ if (rSNL[nPos].equals(rServiceName))
+ return true;
+ }
+
+ return false;
+ }
+
+ public String [] getSupportedServiceNames() throws com.sun.star.uno.RuntimeException {
+ return new String[]{__serviceName};
+ }
+
+ // XTypeProvider
+ public Type[] getTypes() throws com.sun.star.uno.RuntimeException {
+ try {
+ return new Type[]{new Type(XPerformanceTest.class), new Type(XServiceInfo.class), new Type(XTypeProvider.class)};
+ }
+ catch(Exception exception) {
+ throw new com.sun.star.uno.RuntimeException(exception);
+ }
+ }
+
+ public byte[] getImplementationId() throws com.sun.star.uno.RuntimeException {
+ return new byte[0];
+ }
+ }
+
+ public static class _TestObject implements XBridgeTest2, XRecursiveCall, XServiceInfo, XTypeProvider {
+ private static final String __serviceName = "com.sun.star.test.bridge.JavaTestObject";
+
+ private boolean _bool;
+ private char _char;
+ private byte _byte;
+ private short _short;
+ private short _ushort;
+ private int _long;
+ private int _ulong;
+ private long _hyper;
+ private long _uhyper;
+ private float _float;
+ private double _double;
+ private String _string;
+ private byte _byte2;
+ private short _short2;
+ private Object _xInterface;
+ private Object _any;
+ private TestEnum _testEnum = TestEnum.TEST;
+ private TestElement _testElements[] = new TestElement[0];
+ private TestDataElements _testDataElements = new TestDataElements();
+
+ private int _nLastCallId;
+ private boolean _bFirstCall;
+ private boolean _bSequenceOfCallTestPassed;
+
+ private boolean[] arBool;
+ private char[] arChar;
+ private byte[] arByte;
+ private short[] arShort;
+ private short[] arUShort;
+ private int[] arLong;
+ private int[] arULong;
+ private long[] arHyper;
+ private long[] arUHyper;
+ private float[] arFloat;
+ private double[] arDouble;
+ private String[] arString;
+ private Object[] arObject;
+ private Object[] arAny;
+ private TestEnum[] arEnum;
+ private int[][] arLong2;
+ private int[][][] arLong3;
+ public _TestObject(XMultiServiceFactory xMultiServiceFactory) {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".<init> " + xMultiServiceFactory);
+
+ _nLastCallId = 0;
+ _bFirstCall = true;
+ _bSequenceOfCallTestPassed = true;
+ }
+
+
+ public void setValues(boolean bBool,
+ char cChar,
+ byte nByte,
+ short nShort,
+ short nUShort,
+ int nLong,
+ int nULong,
+ long nHyper,
+ long nUHyper,
+ float fFloat,
+ double fDouble,
+ TestEnum testEnum,
+ String string,
+ byte nByte2,
+ short nShort2,
+ Object xInterface,
+ Object any,
+ TestElement testElements[],
+ TestDataElements testDataElements) throws com.sun.star.uno.RuntimeException
+ {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".setValues:" + any);
+
+ _bool = bBool;
+ _char = cChar;
+ _byte = nByte;
+ _short = nShort;
+ _ushort = nUShort;
+ _long = nLong;
+ _ulong = nULong;
+ _hyper = nHyper;
+ _uhyper = nUHyper;
+ _float = fFloat;
+ _double = fDouble;
+ _testEnum = testEnum;
+ _string = string;
+ _byte2 = nByte2;
+ _short2 = nShort2;
+ _xInterface = xInterface;
+ _any = any;
+ _testElements = testElements;
+ _testDataElements = testDataElements;
+ }
+
+
+
+ public TestDataElements setValues2(/*INOUT*/boolean[] io_bool,
+ /*INOUT*/char[] io_char,
+ /*INOUT*/byte[] io_byte,
+ /*INOUT*/short[] io_short,
+ /*INOUT*/short[] io_ushort,
+ /*INOUT*/int[] io_long,
+ /*INOUT*/int[] io_ulong,
+ /*INOUT*/long[] io_hyper,
+ /*INOUT*/long[] io_uhyper,
+ /*INOUT*/float[] io_float,
+ /*INOUT*/double[] io_double,
+ /*INOUT*/TestEnum[] io_testEnum,
+ /*INOUT*/String[] io_string,
+ /*INOUT*/byte[] io_byte2,
+ /*INOUT*/short[] io_short2,
+ /*INOUT*/Object[] io_xInterface,
+ /*INOUT*/Object[] io_any,
+ /*INOUT*/TestElement[][] io_testElements,
+ /*INOUT*/TestDataElements[] io_testDataElements) throws com.sun.star.uno.RuntimeException
+ {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".setValues2:" + io_any[0]);
+
+ _bool = io_bool[0];
+ _char = io_char[0];
+ _byte = io_byte[0];
+ _short = io_short[0];
+ _ushort = io_ushort[0];
+ _long = io_long[0];
+ _ulong = io_ulong[0];
+ _hyper = io_hyper[0];
+ _uhyper = io_uhyper[0];
+ _float = io_float[0];
+ _double = io_double[0];
+ _testEnum = io_testEnum[0];
+ _string = io_string[0];
+ _byte2 = io_byte2[0];
+ _short2 = io_short2[0];
+ _xInterface = io_xInterface[0];
+ _any = io_any[0];
+ _testElements = io_testElements[0];
+ _testDataElements = io_testDataElements[0];
+
+ io_testElements[ 0 ] =
+ new TestElement [] { io_testElements[ 0 ][ 1 ], io_testElements[ 0 ][ 0 ] };
+
+ return _testDataElements;
+ }
+
+ public TestDataElements getValues(/*OUT*/boolean[] o_bool,
+ /*OUT*/char[] o_char,
+ /*OUT*/byte[] o_byte,
+ /*OUT*/short[] o_short,
+ /*OUT*/short[] o_ushort,
+ /*OUT*/int[] o_long,
+ /*OUT*/int[] o_ulong,
+ /*OUT*/long[] o_hyper,
+ /*OUT*/long[] o_uhyper,
+ /*OUT*/float[] o_float,
+ /*OUT*/double[] o_double,
+ /*OUT*/TestEnum[] o_testEnum,
+ /*OUT*/String[] o_string,
+ /*OUT*/byte[] o_byte2,
+ /*OUT*/short[] o_short2,
+ /*OUT*/Object[] o_xInterface,
+ /*OUT*/Object[] o_any,
+ /*OUT*/TestElement[][] o_testElements,
+ /*OUT*/TestDataElements[] o_testDataElements) throws com.sun.star.uno.RuntimeException
+ {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".getValues:" + _any);
+
+ o_bool[0] = _bool;
+ o_char[0] = _char;
+ o_byte[0] = _byte;
+ o_short[0] = _short;
+ o_ushort[0] = _ushort;
+ o_long[0] = _long;
+ o_ulong[0] = _ulong;
+ o_hyper[0] = _hyper;
+ o_uhyper[0] = _uhyper;
+ o_float[0] = _float;
+ o_double[0] = _double;
+ o_testEnum[0] = _testEnum;
+ o_string[0] = _string;
+ o_byte2[0] = _byte2;
+ o_short2[0] = _short2;
+ o_xInterface[0] = _xInterface;
+ o_any[0] = _any;
+ o_testElements[0] = _testElements;
+ o_testDataElements[0] = _testDataElements;
+
+ return _testDataElements;
+ }
+
+ public SmallStruct echoSmallStruct( SmallStruct i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public MediumStruct echoMediumStruct( MediumStruct i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public BigStruct echoBigStruct( BigStruct i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public TwoFloats echoTwoFloats( TwoFloats i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public FourFloats echoFourFloats( FourFloats i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public MixedFloatAndInteger echoMixedFloatAndInteger( MixedFloatAndInteger i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public ThreeByteStruct echoThreeByteStruct( ThreeByteStruct i_Struct) throws com.sun.star.uno.RuntimeException {
+ return i_Struct;
+ }
+
+ public int testPPCAlignment( long l1, long l2, int i1, long l3, int i2 ) throws com.sun.star.uno.RuntimeException {
+ return i2;
+ }
+
+ public int testPPC64Alignment( double d1, double d2, double d3, int i1 ) throws com.sun.star.uno.RuntimeException {
+ return i1;
+ }
+
+ public double testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) {
+ return d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10;
+ }
+
+ // Attributes
+ public boolean getBool() throws com.sun.star.uno.RuntimeException {
+ return _bool;
+ }
+
+ public void setBool(boolean bool) throws com.sun.star.uno.RuntimeException {
+ _bool = bool;
+ }
+
+ public byte getByte() throws com.sun.star.uno.RuntimeException {
+ return _byte;
+ }
+
+ public void setByte(byte zbyte) throws com.sun.star.uno.RuntimeException {
+ _byte = zbyte;
+ }
+
+ public char getChar() throws com.sun.star.uno.RuntimeException {
+ return _char;
+ }
+
+ public void setChar(char zchar) throws com.sun.star.uno.RuntimeException {
+ _char = zchar;
+ }
+
+ public short getShort() throws com.sun.star.uno.RuntimeException {
+ return _short;
+ }
+
+ public void setShort(short zshort) throws com.sun.star.uno.RuntimeException {
+ _short = zshort;
+ }
+
+ public short getUShort() throws com.sun.star.uno.RuntimeException {
+ return _ushort;
+ }
+
+ public void setUShort(short ushort) throws com.sun.star.uno.RuntimeException {
+ _ushort = ushort;
+ }
+
+ public int getLong() throws com.sun.star.uno.RuntimeException {
+ return _long;
+ }
+
+ public void setLong(int zint) throws com.sun.star.uno.RuntimeException {
+ _long = zint;
+ }
+
+ public int getULong() throws com.sun.star.uno.RuntimeException {
+ return _ulong;
+ }
+
+ public void setULong(int uint) throws com.sun.star.uno.RuntimeException {
+ _ulong = uint;
+ }
+
+ public long getHyper() throws com.sun.star.uno.RuntimeException {
+ return _hyper;
+ }
+
+ public void setHyper(long hyper) throws com.sun.star.uno.RuntimeException {
+ _hyper = hyper;
+ }
+
+ public long getUHyper() throws com.sun.star.uno.RuntimeException {
+ return _uhyper;
+ }
+
+ public void setUHyper(long uhyper) throws com.sun.star.uno.RuntimeException {
+ _uhyper = uhyper;
+ }
+
+ public float getFloat() throws com.sun.star.uno.RuntimeException {
+ return _float;
+ }
+
+ public void setFloat(float zfloat) throws com.sun.star.uno.RuntimeException {
+ _float = zfloat;
+ }
+
+ public double getDouble() throws com.sun.star.uno.RuntimeException {
+ return _double;
+ }
+
+ public void setDouble(double zdouble) throws com.sun.star.uno.RuntimeException {
+ _double = zdouble;
+ }
+
+ public TestEnum getEnum() throws com.sun.star.uno.RuntimeException {
+ return _testEnum;
+ }
+
+ public void setEnum(TestEnum testEnum) throws com.sun.star.uno.RuntimeException {
+ _testEnum = testEnum;
+ }
+
+ public String getString() throws com.sun.star.uno.RuntimeException {
+ return _string;
+ }
+
+ public void setString(String string) throws com.sun.star.uno.RuntimeException {
+ _string = string;
+ }
+
+ public byte getByte2() throws com.sun.star.uno.RuntimeException {
+ return _byte2;
+ }
+
+ public void setByte2(byte zbyte) throws com.sun.star.uno.RuntimeException {
+ _byte2 = zbyte;
+ }
+
+ public short getShort2() throws com.sun.star.uno.RuntimeException {
+ return _short2;
+ }
+
+ public void setShort2(short zshort) throws com.sun.star.uno.RuntimeException {
+ _short2 = zshort;
+ }
+
+ public Object getInterface() throws com.sun.star.uno.RuntimeException {
+ return _xInterface;
+ }
+
+ public void setInterface(Object zinterface) throws com.sun.star.uno.RuntimeException {
+ _xInterface = zinterface;
+ }
+
+ public Object getAny() throws com.sun.star.uno.RuntimeException {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".setAny:" + _any);
+
+ return _any;
+ }
+
+ public void setAny(Object any) throws com.sun.star.uno.RuntimeException {
+ if(DEBUG) System.err.println("##### " + getClass().getName() + ".setAny:" + any);
+
+ _any = any;
+ }
+
+ public TestElement[] getSequence() throws com.sun.star.uno.RuntimeException {
+ return _testElements;
+ }
+
+ public void setSequence(TestElement testElements[]) throws com.sun.star.uno.RuntimeException {
+ _testElements = testElements;
+ }
+
+ public TestDataElements getStruct() throws com.sun.star.uno.RuntimeException {
+ return _testDataElements;
+ }
+
+ public void setStruct(TestDataElements testDataElements) throws com.sun.star.uno.RuntimeException {
+ _testDataElements = testDataElements;
+ }
+
+ public int getRaiseAttr1() {
+ throw new com.sun.star.uno.RuntimeException();
+ }
+
+ public void setRaiseAttr1(int n) throws IllegalArgumentException {
+ throw new IllegalArgumentException();
+ }
+
+ public int getRaiseAttr2() throws IllegalArgumentException {
+ throw new IllegalArgumentException();
+ }
+
+ public TestPolyStruct transportPolyBoolean(TestPolyStruct arg) {
+ Boolean dummy = (Boolean) arg.member;
+ return arg;
+ }
+
+ public void transportPolyHyper(TestPolyStruct[] arg) {
+ Long dummy = (Long) arg[0].member;
+ }
+
+ public void transportPolySequence(
+ TestPolyStruct arg1, TestPolyStruct[] arg2)
+ {
+ Object[] dummy = (Object[]) arg1.member;
+ arg2[0] = arg1;
+ }
+
+ public TestPolyStruct getNullPolyLong() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyString() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyType() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyAny() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolySequence() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyEnum() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyBadEnum() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyStruct() {
+ return new TestPolyStruct();
+ }
+
+ public TestPolyStruct getNullPolyInterface() {
+ return new TestPolyStruct();
+ }
+
+ public Object transportAny(Object value) throws com.sun.star.uno.RuntimeException {
+ return value;
+ }
+
+ public void call(int nCallId , int nWaitMUSEC) throws com.sun.star.uno.RuntimeException {
+ try {
+ Thread.sleep(nWaitMUSEC / 10000);
+ }
+ catch(InterruptedException interruptedException) {
+ throw new com.sun.star.uno.RuntimeException(interruptedException);
+ }
+
+ if(_bFirstCall)
+ _bFirstCall = false;
+
+ else
+ _bSequenceOfCallTestPassed = _bSequenceOfCallTestPassed && (nCallId > _nLastCallId);
+
+ _nLastCallId = nCallId;
+ }
+
+ public void callOneway( int nCallId , int nWaitMUSEC ) throws com.sun.star.uno.RuntimeException {
+ try {
+ Thread.sleep(nWaitMUSEC / 10000);
+ }
+ catch(InterruptedException interruptedException) {
+ throw new com.sun.star.uno.RuntimeException(interruptedException);
+ }
+
+ _bSequenceOfCallTestPassed = _bSequenceOfCallTestPassed && (nCallId > _nLastCallId);
+ _nLastCallId = nCallId;
+ }
+
+ public boolean sequenceOfCallTestPassed() throws com.sun.star.uno.RuntimeException {
+ return _bSequenceOfCallTestPassed;
+ }
+
+ public synchronized void callRecursivly(XRecursiveCall xCall, int nToCall) throws com.sun.star.uno.RuntimeException {
+ if(nToCall != 0)
+ {
+ nToCall --;
+ xCall.callRecursivly(this , nToCall);
+ }
+ }
+
+ public synchronized void startRecursiveCall(XRecursiveCall xCall, int nToCall) throws com.sun.star.uno.RuntimeException {
+ if(nToCall != 0)
+ {
+ nToCall --;
+ xCall.callRecursivly( this , nToCall );
+ }
+ }
+
+ public XMulti getMulti() {
+ return new XMulti() {
+ public double getatt1() {
+ return attribute1;
+ }
+
+ public void setatt1(double value) {
+ attribute1 = value;
+ }
+
+ public int fn11(int arg) {
+ return 11 * arg;
+ }
+
+ public String fn12(String arg) {
+ return "12" + arg;
+ }
+
+ public int fn21(int arg) {
+ return 21 * arg;
+ }
+
+ public String fn22(String arg) {
+ return "22" + arg;
+ }
+
+ public double getatt3() {
+ return attribute3;
+ }
+
+ public void setatt3(double value) {
+ attribute3 = value;
+ }
+
+ public int fn31(int arg) {
+ return 31 * arg;
+ }
+
+ public String fn32(String arg) {
+ return "32" + arg;
+ }
+
+ public int fn33() {
+ return 33;
+ }
+
+ public int fn41(int arg) {
+ return 41 * arg;
+ }
+
+ public int fn61(int arg) {
+ return 61 * arg;
+ }
+
+ public String fn62(String arg) {
+ return "62" + arg;
+ }
+
+ public int fn71(int arg) {
+ return 71 * arg;
+ }
+
+ public String fn72(String arg) {
+ return "72" + arg;
+ }
+
+ public int fn73() {
+ return 73;
+ }
+
+ private double attribute1 = 0.0;
+ private double attribute3 = 0.0;
+ };
+ }
+
+ private static final class CheckFailed extends Exception {
+ CheckFailed(String message) {
+ super(message);
+ }
+ }
+
+ private static void checkEqual(int value, int argument)
+ throws CheckFailed
+ {
+ if (argument != value) {
+ throw new CheckFailed(value + " != " + argument);
+ }
+ }
+
+ private static void checkEqual(double value, double argument)
+ throws CheckFailed
+ {
+ if (argument != value) {
+ throw new CheckFailed(value + " != " + argument);
+ }
+ }
+
+ private static void checkEqual(String value, String argument)
+ throws CheckFailed
+ {
+ if (!argument.equals(value)) {
+ throw new CheckFailed(value + " != " + argument);
+ }
+ }
+
+ public String testMulti(XMulti multi) {
+ try {
+ checkEqual(0.0, multi.getatt1());
+ multi.setatt1(0.1);
+ checkEqual(0.1, multi.getatt1());
+ checkEqual(11 * 1, multi.fn11(1));
+ checkEqual("12" + "abc", multi.fn12("abc"));
+ checkEqual(21 * 2, multi.fn21(2));
+ checkEqual("22" + "de", multi.fn22("de"));
+ checkEqual(0.0, multi.getatt3());
+ multi.setatt3(0.3);
+ checkEqual(0.3, multi.getatt3());
+ checkEqual(31 * 3, multi.fn31(3));
+ checkEqual("32" + "f", multi.fn32("f"));
+ checkEqual(33, multi.fn33());
+ checkEqual(41 * 4, multi.fn41(4));
+ checkEqual(61 * 6, multi.fn61(6));
+ checkEqual("62", multi.fn62(""));
+ checkEqual(71 * 7, multi.fn71(7));
+ checkEqual("72" + "g", multi.fn72("g"));
+ checkEqual(73, multi.fn73());
+ } catch (CheckFailed f) {
+ return f.getMessage();
+ }
+ return "";
+ }
+
+ // XBridgeTest
+ public TestDataElements raiseException(short nArgumentPos, String rMsg, Object xContext)
+ throws com.sun.star.lang.IllegalArgumentException,
+ com.sun.star.uno.RuntimeException
+ {
+ throw new com.sun.star.lang.IllegalArgumentException(rMsg, xContext, nArgumentPos);
+ }
+
+ public void raiseRuntimeExceptionOneway(String rMsg, Object xContext) throws com.sun.star.uno.RuntimeException {
+ throw new com.sun.star.uno.RuntimeException(rMsg, xContext);
+ }
+
+ private void dothrow( com.sun.star.uno.RuntimeException t )
+ throws com.sun.star.uno.RuntimeException
+ {
+ throw t;
+ }
+ public int getRuntimeException()
+ throws com.sun.star.uno.RuntimeException
+ {
+ dothrow( new com.sun.star.uno.RuntimeException(
+ _string, _xInterface ) );
+ return 0; // dummy
+ }
+
+ public void setRuntimeException(int _runtimeexception) throws com.sun.star.uno.RuntimeException {
+ throw new com.sun.star.uno.RuntimeException(_string, _xInterface);
+ }
+
+
+
+ // XServiceInfo
+ public String getImplementationName() throws com.sun.star.uno.RuntimeException {
+ return __serviceName;
+ }
+
+ public boolean supportsService(String rServiceName) throws com.sun.star.uno.RuntimeException {
+ String rSNL[] = getSupportedServiceNames();
+
+ for(int nPos = rSNL.length; (nPos--) != 0;) {
+ if (rSNL[nPos].equals(rServiceName))
+ return true;
+ }
+
+ return false;
+ }
+
+ public String [] getSupportedServiceNames() throws com.sun.star.uno.RuntimeException {
+ return new String[]{__serviceName};
+ }
+
+ // XTypeProvider
+ public Type[] getTypes() throws com.sun.star.uno.RuntimeException {
+ try {
+ return new Type[]{new Type(XBridgeTest.class), new Type(XRecursiveCall.class), new Type(XServiceInfo.class), new Type(XTypeProvider.class)};
+ }
+ catch(Exception exception) {
+ throw new com.sun.star.uno.RuntimeException(exception);
+ }
+ }
+
+ public byte[] getImplementationId() throws com.sun.star.uno.RuntimeException {
+ return new byte[0];
+ }
+
+ //XBridgeTest2
+ public boolean[] setSequenceBool( /*IN*/boolean[] aSeq )
+ {
+ arBool = aSeq;
+ return aSeq;
+ }
+ public char[] setSequenceChar( /*IN*/char[] aSeq )
+ {
+ arChar = aSeq;
+ return aSeq;
+ }
+ public byte[] setSequenceByte( /*IN*/byte[] aSeq )
+ {
+ arByte = aSeq;
+ return aSeq;
+ }
+ public short[] setSequenceShort( /*IN*/short[] aSeq )
+ {
+ arShort = aSeq;
+ return aSeq;
+ }
+ public short[] setSequenceUShort( /*IN*/short[] aSeq )
+ {
+ arUShort = aSeq;
+ return aSeq;
+ }
+ public int[] setSequenceLong( /*IN*/int[] aSeq )
+ {
+ arLong = aSeq;
+ return aSeq;
+ }
+ public int[] setSequenceULong( /*IN*/int[] aSeq )
+ {
+ arULong = aSeq;
+ return aSeq;
+ }
+ public long[] setSequenceHyper( /*IN*/long[] aSeq )
+ {
+ arHyper = aSeq;
+ return aSeq;
+ }
+ public long[] setSequenceUHyper( /*IN*/long[] aSeq )
+ {
+ arUHyper = aSeq;
+ return aSeq;
+ }
+ public float[] setSequenceFloat( /*IN*/float[] aSeq )
+ {
+ arFloat = aSeq;
+ return aSeq;
+ }
+ public double[] setSequenceDouble( /*IN*/double[] aSeq )
+ {
+ arDouble = aSeq;
+ return aSeq;
+ }
+ public TestEnum[] setSequenceEnum( /*IN*/TestEnum[] aSeq )
+ {
+ arEnum = aSeq;
+ return aSeq;
+ }
+ public String[] setSequenceString( /*IN*/String[] aSeq )
+ {
+ arString = aSeq;
+ return aSeq;
+ }
+ public java.lang.Object[] setSequenceXInterface( /*IN*/java.lang.Object[] aSeq )
+ {
+ arObject = aSeq;
+ return aSeq;
+ }
+ public java.lang.Object[] setSequenceAny( /*IN*/java.lang.Object[] aSeq )
+ {
+ arAny = aSeq;
+ return aSeq;
+ }
+ public TestElement[] setSequenceStruct( /*IN*/TestElement[] aSeq )
+ {
+ _testElements = aSeq;
+ return aSeq;
+ }
+ public int[][] setDim2( /*IN*/int[][] aSeq )
+ {
+ arLong2 = aSeq;
+ return aSeq;
+ }
+ public int[][][] setDim3( /*IN*/int[][][] aSeq )
+ {
+ arLong3 = aSeq;
+ return aSeq;
+ }
+ public void setSequencesInOut( /*INOUT*/boolean[][] aSeqBoolean,
+ /*INOUT*/char[][] aSeqChar, /*INOUT*/byte[][] aSeqByte,
+ /*INOUT*/short[][] aSeqShort, /*INOUT*/short[][] aSeqUShort,
+ /*INOUT*/int[][] aSeqLong, /*INOUT*/int[][] aSeqULong,
+ /*INOUT*/long[][] aSeqHyper, /*INOUT*/long[][] aSeqUHyper,
+ /*INOUT*/float[][] aSeqFloat, /*INOUT*/double[][] aSeqDouble,
+ /*INOUT*/TestEnum[][] aSeqEnum, /*INOUT*/String[][] aSeqString,
+ /*INOUT*/java.lang.Object[][] aSeqXInterface,
+ /*INOUT*/java.lang.Object[][] aSeqAny,
+ /*INOUT*/int[][][] aSeqDim2, /*INOUT*/int[][][][] aSeqDim3 )
+ {
+ arBool = aSeqBoolean[0];
+ arChar = aSeqChar[0];
+ arByte = aSeqByte[0];
+ arShort = aSeqShort[0];
+ arUShort = aSeqUShort[0];
+ arLong = aSeqLong[0];
+ arULong = aSeqULong[0];
+ arFloat = aSeqFloat[0];
+ arDouble = aSeqDouble[0];
+ arEnum = aSeqEnum[0];
+ arString = aSeqString[0];
+ arObject = aSeqXInterface[0];
+ arAny = aSeqAny[0];
+ arLong2 = aSeqDim2[0];
+ arLong3 = aSeqDim3[0];
+ }
+ public void setSequencesOut( /*OUT*/boolean[][] aSeqBoolean, /*OUT*/char[][] aSeqChar,
+ /*OUT*/byte[][] aSeqByte, /*OUT*/short[][] aSeqShort,
+ /*OUT*/short[][] aSeqUShort, /*OUT*/int[][] aSeqLong,
+ /*OUT*/int[][] aSeqULong, /*OUT*/long[][] aSeqHyper,
+ /*OUT*/long[][] aSeqUHyper, /*OUT*/float[][] aSeqFloat,
+ /*OUT*/double[][] aSeqDouble, /*OUT*/TestEnum[][] aSeqEnum,
+ /*OUT*/String[][] aSeqString,
+ /*OUT*/java.lang.Object[][] aSeqXInterface,
+ /*OUT*/java.lang.Object[][] aSeqAny, /*OUT*/int[][][] aSeqDim2,
+ /*OUT*/int[][][][] aSeqDim3 )
+ {
+ aSeqBoolean[0] = arBool;
+ aSeqChar[0] = arChar;
+ aSeqByte[0] = arByte;
+ aSeqShort[0] = arShort;
+ aSeqUShort[0] = arUShort;
+ aSeqLong[0] = arLong;
+ aSeqULong[0] = arULong;
+ aSeqHyper[0] = arHyper;
+ aSeqUHyper[0] = arUHyper;
+ aSeqFloat[0] = arFloat;
+ aSeqDouble[0] = arDouble;
+ aSeqEnum[0] = arEnum;
+ aSeqString[0] = arString;
+ aSeqXInterface[0] = arObject;
+ aSeqAny[0] = arAny;
+ aSeqDim2[0] = arLong2;
+ aSeqDim3[0] = arLong3;
+ }
+
+ public void testConstructorsService(XComponentContext context)
+ throws BadConstructorArguments
+ {
+ Constructors.create1(context,
+ true,
+ Byte.MIN_VALUE,
+ Short.MIN_VALUE,
+ (short) -1,
+ Integer.MIN_VALUE,
+ -1,
+ Long.MIN_VALUE,
+ -1L,
+ 0.123f,
+ 0.456,
+ 'X',
+ "test",
+ Type.ANY,
+ new Any(Type.BOOLEAN, Boolean.TRUE),
+ new boolean[] { true },
+ new byte[] { Byte.MIN_VALUE },
+ new short[] { Short.MIN_VALUE },
+ new short[] { (short) -1 },
+ new int[] { Integer.MIN_VALUE },
+ new int[] { -1 },
+ new long[] { Long.MIN_VALUE },
+ new long[] { -1L },
+ new float[] { 0.123f },
+ new double[] { 0.456 },
+ new char[] { 'X' },
+ new String[] { "test" },
+ new Type[] { Type.ANY },
+ new Boolean[] { Boolean.TRUE },
+ new boolean[][] { new boolean[] { true } },
+ new Object[][] {
+ new Object[] { new Any(Type.BOOLEAN, Boolean.TRUE) } },
+ new TestEnum[] { TestEnum.TWO },
+ new TestStruct[] { new TestStruct(10) },
+ new TestPolyStruct[] { new TestPolyStruct(Boolean.TRUE) },
+ new TestPolyStruct[] {
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE)) },
+ new Object[] { null },
+ TestEnum.TWO,
+ new TestStruct(10),
+ new TestPolyStruct(Boolean.TRUE),
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE)),
+ null);
+ Constructors.create2(context, new Object[] {
+ Boolean.TRUE,
+ Byte.valueOf(Byte.MIN_VALUE),
+ Short.valueOf(Short.MIN_VALUE),
+ new Any(Type.UNSIGNED_SHORT, Short.valueOf((short) -1)),
+ Integer.valueOf(Integer.MIN_VALUE),
+ new Any(Type.UNSIGNED_LONG, Integer.valueOf(-1)),
+ Long.valueOf(Long.MIN_VALUE),
+ new Any(Type.UNSIGNED_HYPER, Long.valueOf(-1L)),
+ new Float(0.123f),
+ new Double(0.456),
+ new Character('X'),
+ "test",
+ Type.ANY,
+ new Any(Type.BOOLEAN, Boolean.TRUE),
+ new boolean[] { true },
+ new byte[] { Byte.MIN_VALUE },
+ new short[] { Short.MIN_VALUE },
+ new Any(
+ new Type("[]unsigned short"), new short[] { (short) -1 }),
+ new int[] { Integer.MIN_VALUE },
+ new Any(new Type("[]unsigned long"), new int[] { -1 }),
+ new long[] { Long.MIN_VALUE },
+ new Any(new Type("[]unsigned hyper"), new long[] { -1L }),
+ new float[] { 0.123f },
+ new double[] { 0.456 },
+ new char[] { 'X' },
+ new String[] { "test" },
+ new Type[] { Type.ANY },
+ new Any(new Type("[]any"), new Boolean[] { Boolean.TRUE }),
+ new boolean[][] { new boolean[] { true } },
+ new Object[][] {
+ new Object[] { new Any(Type.BOOLEAN, Boolean.TRUE) } },
+ new TestEnum[] { TestEnum.TWO },
+ new TestStruct[] { new TestStruct(10) },
+ new Any(
+ new Type(
+ "[]test.testtools.bridgetest.TestPolyStruct<boolean>"),
+ new TestPolyStruct[] { new TestPolyStruct(Boolean.TRUE) }),
+ new Any(
+ new Type("[]test.testtools.bridgetest.TestPolyStruct<any>"),
+ new TestPolyStruct[] {
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE))
+ }),
+ new XInterface[] { null },
+ TestEnum.TWO,
+ new TestStruct(10),
+ new Any(
+ new Type(
+ "test.testtools.bridgetest.TestPolyStruct<boolean>"),
+ new TestPolyStruct(Boolean.TRUE)),
+ new Any(
+ new Type("test.testtools.bridgetest.TestPolyStruct<any>"),
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE))),
+ null });
+ Constructors2.create1(
+ context,
+ new TestPolyStruct(Type.LONG),
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE)),
+ new TestPolyStruct(Boolean.TRUE),
+ new TestPolyStruct(Byte.valueOf(Byte.MIN_VALUE)),
+ new TestPolyStruct(Short.valueOf(Short.MIN_VALUE)),
+ new TestPolyStruct(Integer.valueOf(Integer.MIN_VALUE)),
+ new TestPolyStruct(Long.valueOf(Long.MIN_VALUE)),
+ new TestPolyStruct(new Character('X')),
+ new TestPolyStruct("test"),
+ new TestPolyStruct(new Float(0.123f)),
+ new TestPolyStruct(new Double(0.456)),
+ new TestPolyStruct(new com.sun.star.lib.uno.helper.ComponentBase()),
+ new TestPolyStruct(new com.sun.star.lib.uno.helper.ComponentBase()),
+ new TestPolyStruct(TestEnum.TWO),
+ new TestPolyStruct(new TestPolyStruct2(new Character('X'),
+ new Any(Type.BOOLEAN, Boolean.TRUE))),
+ new TestPolyStruct(new TestPolyStruct2(new TestPolyStruct2(
+ new Character('X'), new Any(Type.BOOLEAN, Boolean.TRUE)), "test")),
+ new TestPolyStruct2("test", new TestPolyStruct2(new Character('X'),
+ new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE)))),
+ new TestPolyStruct2( new TestPolyStruct2(new Character('X'),
+ new Any(Type.BOOLEAN, Boolean.TRUE)), new TestPolyStruct(new Character('X'))),
+ new TestPolyStruct(new Type[] { Type.LONG}),
+ new TestPolyStruct(new Any[] { new Any(Type.BOOLEAN, Boolean.TRUE) }),
+ new TestPolyStruct(new boolean[] {true}),
+ new TestPolyStruct(new byte[] {Byte.MIN_VALUE}),
+ new TestPolyStruct(new short[] {Short.MIN_VALUE}),
+ new TestPolyStruct(new int[] {Integer.MIN_VALUE}),
+ new TestPolyStruct(new long[] {Long.MIN_VALUE}),
+ new TestPolyStruct(new char[] {'X'}),
+ new TestPolyStruct(new String[] {"test"}),
+ new TestPolyStruct(new float[] {0.123f}),
+ new TestPolyStruct(new double[] {0.456d}),
+ new TestPolyStruct(new Object[] {new com.sun.star.lib.uno.helper.ComponentBase()}),
+ new TestPolyStruct(new com.sun.star.lang.XComponent[] {new com.sun.star.lib.uno.helper.ComponentBase()}),
+ new TestPolyStruct(new TestEnum[] {TestEnum.TWO}),
+ new TestPolyStruct(new TestPolyStruct2[] {new TestPolyStruct2(
+ new Character('X'), new Any[] {new Any(Type.BOOLEAN, Boolean.TRUE)})}),
+ new TestPolyStruct(new TestPolyStruct2[] {new TestPolyStruct2(
+ new TestPolyStruct(new Character('X')), new Any[] {new Any(Type.BOOLEAN, Boolean.TRUE)})}),
+ new TestPolyStruct(new int[][] { new int[] {Integer.MIN_VALUE} }),
+ new TestPolyStruct[]{ new TestPolyStruct(Integer.valueOf(Integer.MIN_VALUE))},
+ new TestPolyStruct[]{new TestPolyStruct(new TestPolyStruct2(
+ new Character('X'), new Any(Type.BOOLEAN, Boolean.TRUE)))},
+ new TestPolyStruct[]{new TestPolyStruct(new TestPolyStruct2(
+ new TestPolyStruct2(new Character('X'), new Any(Type.BOOLEAN, Boolean.TRUE)), "test"))},
+ new TestPolyStruct2[]{new TestPolyStruct2("test", new TestPolyStruct2(
+ new Character('X'), new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE))))},
+ new TestPolyStruct2[]{new TestPolyStruct2(new TestPolyStruct2(new Character('X'), new Any(
+ Type.BOOLEAN, Boolean.TRUE)),new TestPolyStruct(new Character('X')))},
+ new TestPolyStruct[][]{new TestPolyStruct[]{new TestPolyStruct(new Character('X'))}},
+ new TestPolyStruct[][]{new TestPolyStruct[]{
+ new TestPolyStruct(new TestPolyStruct2(new Character('X'), new Any(Type.BOOLEAN, Boolean.TRUE)))}},
+ new TestPolyStruct[][]{new TestPolyStruct[] {new TestPolyStruct(new TestPolyStruct2(
+ new TestPolyStruct2(new Character('X'),new Any(Type.BOOLEAN, Boolean.TRUE)), "test"))}},
+ new TestPolyStruct2[][]{new TestPolyStruct2[]{new TestPolyStruct2(
+ "test", new TestPolyStruct2(new Character('X'),new TestPolyStruct(new Any(Type.BOOLEAN, Boolean.TRUE))))}},
+ new TestPolyStruct2[][]{new TestPolyStruct2[]{new TestPolyStruct2(
+ new TestPolyStruct2(new Character('X'),new Any(Type.BOOLEAN, Boolean.TRUE)),
+ new TestPolyStruct(new Character('X')))}});
+ }
+
+ public XCurrentContextChecker getCurrentContextChecker() {
+ return new CurrentContextChecker();
+ }
+ }
+
+ /**
+ * Gives a factory for creating the service.
+ * This method is called by the <code>JavaLoader</code>
+ * <p>
+ * @return returns a <code>XSingleServiceFactory</code> for creating the component
+ * @param implName the name of the implementation for which a service is desired
+ * @param multiFactory the service manager to be uses if needed
+ * @param regKey the registryKey
+ * @see com.sun.star.comp.loader.JavaLoader
+ */
+ public static XSingleServiceFactory __getServiceFactory(String implName,
+ XMultiServiceFactory multiFactory,
+ XRegistryKey regKey)
+ {
+ XSingleServiceFactory xSingleServiceFactory = null;
+
+ if(implName.equals(_TestObject.class.getName()))
+ xSingleServiceFactory = FactoryHelper.getServiceFactory(_TestObject.class,
+ _TestObject.__serviceName,
+ multiFactory,
+ regKey);
+
+ else if(implName.equals(_PerformancTestObject.class.getName()))
+ xSingleServiceFactory = FactoryHelper.getServiceFactory(_PerformancTestObject.class,
+ _PerformancTestObject.__serviceName,
+ multiFactory,
+ regKey);
+
+ return xSingleServiceFactory;
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 02:11:23 +0000