/**************************************************************
*
* 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;
}
}