/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ package com.sun.star.lib.uno.typedesc; import com.sun.star.lib.uno.typeinfo.MethodTypeInfo; import com.sun.star.lib.uno.typeinfo.TypeInfo; import com.sun.star.uno.Any; import com.sun.star.uno.IFieldDescription; import com.sun.star.uno.IMethodDescription; import com.sun.star.uno.ITypeDescription; import com.sun.star.uno.Type; import com.sun.star.uno.TypeClass; import com.sun.star.uno.XInterface; import com.sun.star.uno.XNamingService; import complexlib.ComplexTestCase; public final class TypeDescription_Test extends ComplexTestCase { public String getTestObjectName() { return getClass().getName(); } public String[] getTestMethodNames() { return new String[] { "test", "testUnsigned", "testGetMethodDescription", "testSequence" }; } public void test() throws Exception { ITypeDescription voidTD = TypeDescription.getTypeDescription( void.class); ITypeDescription stringTD = TypeDescription.getTypeDescription( String.class); ITypeDescription typeTD = TypeDescription.getTypeDescription( Type.class); ITypeDescription anyTD = TypeDescription.getTypeDescription(Any.class); ITypeDescription interfaceTD = TypeDescription.getTypeDescription( XInterface.class); MethodSignature sigBuildinSyncTypeToAny = new MethodSignature( true, false, new ITypeDescription[] { typeTD }, new ITypeDescription[1], anyTD); MethodSignature sigBuildinAsyncToVoid = new MethodSignature( true, true, new ITypeDescription[0], new ITypeDescription[0], voidTD); MethodSignature sigAddonSyncStringToVoid = new MethodSignature( false, false, new ITypeDescription[] { stringTD }, new ITypeDescription[1], voidTD); MethodSignature sigAddonSyncStringInterfaceToVoid = new MethodSignature( false, false, new ITypeDescription[] { stringTD, interfaceTD }, new ITypeDescription[2], voidTD); MethodSignature sigAddonSyncStringToInterface = new MethodSignature( false, false, new ITypeDescription[] { stringTD }, new ITypeDescription[1], interfaceTD); TypeSignature emptyTypeSig = new TypeSignature( null, new String[0], null, new String[0], null); TypeSignature interfaceTypeSig = new TypeSignature( null, new String[] { "queryInterface", "acquire", "release" }, new MethodSignature[] { sigBuildinSyncTypeToAny, sigBuildinAsyncToVoid, sigBuildinAsyncToVoid }, new String[0], null); TypeSignature exceptionTypeSig = new TypeSignature( null, new String[0], null, new String[]{"Context"}, new TypeSignature[] { interfaceTypeSig }); // com.sun.star.uno.Exception.idl says that Exception (a) has no // base exception, and (b) has two fields, Message and Context; the // generated com.sun.star.uno.Exception.java, however, (a) is // inherited from java.lang.Exception, and (b) has only one field, // Context, as Message is inherited from java.lang.Exception TypeSignature namingServiceTypeSig = new TypeSignature( interfaceTypeSig, new String[] { "getRegisteredObject", "registerObject", "revokeObject" }, new MethodSignature[] { sigAddonSyncStringToInterface, sigAddonSyncStringInterfaceToVoid, sigAddonSyncStringToVoid }, new String[0], null); Object[] byteData = new Object[] { "byte", "[B", byte.class, TypeClass.BYTE }; Object[] stringData = new Object[] { "string", "[Ljava.lang.String;", java.lang.String.class, TypeClass.STRING }; Object[] typeClassData = new Object[] { "com.sun.star.uno.TypeClass", "[Lcom.sun.star.uno.TypeClass;", TypeClass.class, TypeClass.ENUM }; Object[] interfaceData = new Object[] { "com.sun.star.uno.XInterface", "[Lcom.sun.star.uno.XInterface;", XInterface.class, TypeClass.INTERFACE }; Object[] exceptionData = new Object [] { "com.sun.star.uno.Exception", "[Lcom.sun.star.uno.Exception;", com.sun.star.uno.Exception.class, TypeClass.EXCEPTION, new Object[] { interfaceData } }; Object[] namingServiceData = new Object[] { "com.sun.star.uno.XNamingService", "[Lcom.sun.star.uno.XNamingService;", XNamingService.class, TypeClass.INTERFACE, null, interfaceData }; emptyTypeSig.test("TypeSignature.test(byte)", byteData, TypeDescription.getTypeDescription("byte")); emptyTypeSig.test("TypeSignature.test(string)", stringData, TypeDescription.getTypeDescription("string")); emptyTypeSig.test("TypeSignature.test(TypeClass)", typeClassData, TypeDescription.getTypeDescription( "com.sun.star.uno.TypeClass")); exceptionTypeSig.test("TypeSignature.test(com.sun.star.uno.Exception)", exceptionData, TypeDescription.getTypeDescription( "com.sun.star.uno.Exception")); interfaceTypeSig.test("TypeSignature.test(XInterface)", interfaceData, TypeDescription.getTypeDescription( "com.sun.star.uno.XInterface")); namingServiceTypeSig.test("TypeSignature.test(XNamingService)", namingServiceData, TypeDescription.getTypeDescription( "com.sun.star.uno.XNamingService")); } public void testUnsigned() throws ClassNotFoundException { assure("TypeDescription for UNSIGNED LONG", TypeDescription.getTypeDescription(Type.UNSIGNED_LONG). getTypeName().equals("unsigned long")); } public void testGetMethodDescription() { TypeDescription td = TypeDescription.getTypeDescription(XDerived.class); td.getMethodDescription("fn"); } public void testSequence() throws ClassNotFoundException { assure( TypeDescription.getTypeDescription("[]unsigned short"). getComponentType().getTypeName().equals("unsigned short")); } public interface XBase extends XInterface { void fn(); TypeInfo[] UNOTYPEINFO = { new MethodTypeInfo("fn", 0, 0) }; } public interface XDerived extends XBase { TypeInfo[] UNOTYPEINFO = null; } private final class MethodSignature { public MethodSignature( boolean buildIn, boolean oneWay, ITypeDescription[] inParameters, ITypeDescription[] outParameters, ITypeDescription returnValue) { this.buildIn = buildIn; this.oneWay = oneWay; this.inParameters = inParameters; this.outParameters = outParameters; this.returnValue = returnValue; } public void test(String prefix, int index, IMethodDescription description) { assure(prefix + "; getIndex", description.getIndex() == index); assure(prefix + "; getMethod", (description.getMethod() == null) == buildIn); assure(prefix + "; isOneway", description.isOneway() == oneWay); ITypeDescription[] in = description.getInSignature(); assure(prefix + "; getInSignature", in.length == inParameters.length); for (int i = 0; i < in.length; ++i) { assure(prefix + "; getInSignature " + i, in[i].equals(inParameters[i])); } ITypeDescription[] out = description.getOutSignature(); assure(prefix + "; getOutSignature", out.length == outParameters.length); for (int i = 0; i < out.length; ++i) { assure(prefix + "; getOutSignature " + i, out[i] == null ? outParameters[i] == null : out[i].equals(outParameters[i])); } assure(prefix + "; getReturnSignature", description.getReturnSignature().equals(returnValue)); } private final boolean buildIn; private final boolean oneWay; private final ITypeDescription[] inParameters; private final ITypeDescription[] outParameters; private final ITypeDescription returnValue; } private final class TypeSignature { public TypeSignature(TypeSignature superType, String[] methodNames, MethodSignature[] methodSignatures, String[] fieldNames, TypeSignature[] fieldSignatures) { this._superType = superType; this.methodNames = methodNames; this.methodSignatures = methodSignatures; methodOffset = superType == null ? 0 : superType.methodOffset + superType.methodNames.length; this.fieldSignatures = fieldSignatures; this.fieldNames = fieldNames; fieldOffset = superType == null ? 0 : superType.fieldOffset + superType.fieldNames.length; } public void test(String prefix, Object[] data, ITypeDescription description) throws Exception { assure(prefix + "; getTypeName", description.getTypeName().equals(data[0])); assure(prefix + "; equals", description.equals(TypeDescription.getTypeDescription( (String)data[0]))); assure(prefix + "; getArrayTypeName", description.getArrayTypeName().equals(data[1])); assure(prefix + "; getZClass", description.getZClass() == data[2]); assure(prefix + "; getTypeClass", description.getTypeClass() == data[3]); assure(prefix + "; getComponentType", description.getComponentType() == null); IMethodDescription[] mds = description.getMethodDescriptions(); assure( prefix + "; getMethodDescriptions", mds == null ? methodSignatures == null : mds.length == methodSignatures.length); if (methodSignatures != null) { for (int i = 0; i < methodSignatures.length; ++i) { methodSignatures[i].test( prefix + "; getMethodDescriptions " + i, i + methodOffset, mds[i]); } } for (int i = 0; i < methodNames.length; ++i) { IMethodDescription md = description.getMethodDescription( i + methodOffset); assure(prefix + "; getMethodDescription " + (i + methodOffset), md != null); methodSignatures[i].test( prefix + "; getMethodDescription " + (i + methodOffset), i + methodOffset, md); } for (int i = 0; i < methodNames.length; ++i) { IMethodDescription md = description.getMethodDescription( methodNames[i]); assure(prefix + "; getMethodDescription " + methodNames[i], md != null); methodSignatures[i].test( prefix + "; getMethodDescription " + methodNames[i], i + methodOffset, md); } IFieldDescription[] fds = description.getFieldDescriptions(); assure( prefix + "; getFieldDescriptions", fds == null ? fieldSignatures == null : fds.length == fieldSignatures.length); if (fieldSignatures != null) { for (int i = 0; i < fieldSignatures.length; ++i) { fieldSignatures[i].test( prefix + "; getFieldDescriptions " + i, (Object[]) ((Object[]) data[4])[i], fds[i].getTypeDescription()); } } ITypeDescription supert = description.getSuperType(); assure(prefix + "; getSuperType", (supert == null) == (data.length < 6)); if (supert != null && data[5] != null) { _superType.test(prefix + "; getSuperType", (Object[]) data[5], supert); } } private final TypeSignature _superType; private final MethodSignature[] methodSignatures; private final String[] methodNames; private final int methodOffset; private final TypeSignature[] fieldSignatures; private final String[] fieldNames; private final int fieldOffset; } }