/******************************************************************************* | |
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* Oracle - initial API and implementation from Oracle TopLink | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.tests.remote; | |
import java.util.*; | |
import java.lang.reflect.*; | |
import org.eclipse.persistence.internal.sessions.remote.RemoteConnection; | |
import org.eclipse.persistence.exceptions.*; | |
import org.eclipse.persistence.sessions.remote.RemoteSession; | |
import org.eclipse.persistence.testing.framework.*; | |
public class RemoteConnectionExceptionsTest extends TestCase { | |
public RemoteConnectionExceptionsTest(int mode, Class remoteConnectionClass) { | |
this.remoteConnectionClass = remoteConnectionClass; | |
generator = new TransporterGenerator(mode); | |
setNameAndCheckMode(); | |
setNamesToExclude(); | |
setMethodsAndArgs(); | |
setKnownBugs(); | |
} | |
public RemoteConnectionExceptionsTest(int mode, | |
String remoteConnectionClassName) throws ClassNotFoundException { | |
this(mode, Class.forName(remoteConnectionClassName)); | |
} | |
protected Class remoteConnectionClass; | |
private RemoteConnection remoteConnection; | |
protected TransporterGenerator generator; | |
protected Object[] results; | |
protected Throwable[] exceptions; | |
protected Hashtable knownBugs; | |
protected Vector namesToExclude; | |
protected Vector methods; | |
protected Vector args; | |
protected void setRemoteConnection(RemoteConnection remoteConnection) { | |
Class cls = remoteConnection.getClass(); | |
if (!remoteConnectionClass.equals(cls)) { | |
throw new TestProblemException("remoteConnection's type is different from the type used to create the test"); | |
} | |
this.remoteConnection = remoteConnection; | |
this.remoteConnection.setSession(new RemoteSession()); | |
} | |
protected RemoteConnection getRemoteConnection() { | |
return remoteConnection; | |
} | |
protected void setNamesToExclude() { | |
namesToExclude = new Vector(); | |
String namesToExcludeArray[] = | |
{ "createProxySession", "createRemoteSession", "cursoredStreamNextPage", "fixObjectReferences", | |
"getRemoteSessionController", "setRemoteSessionController", }; | |
for (int i = 0; i < namesToExcludeArray.length; i++) { | |
namesToExclude.add(namesToExcludeArray[i]); | |
} | |
} | |
protected void setNameAndCheckMode() throws TestProblemException { | |
int mode = generator.getMode(); | |
String className = remoteConnectionClass.getName(); | |
if (mode == TransporterGenerator.THROW_REMOTE_EXCEPTION) { | |
setName(getName().concat(" THROW_REMOTE_EXCEPTION")); | |
setDescription("Verifies that CommunicationException are thrown by methods of " + className + | |
" class"); | |
} else if (mode == TransporterGenerator.SET_EXCEPTION_INTO_TRANSPORTER) { | |
setName(getName().concat(" SET_EXCEPTION_INTO_TRANSPORTER")); | |
setDescription("Verifies that Transporter.getException() are thrown by methods of " + className + | |
" class"); | |
} else { | |
throw new TestProblemException("Unsupported mode"); | |
} | |
} | |
protected void setMethodsAndArgs() { | |
methods = new Vector(); | |
args = new Vector(); | |
Method[] allMethods = remoteConnectionClass.getMethods(); | |
for (int i = 0; i < allMethods.length; i++) { | |
Method method = allMethods[i]; | |
if (!method.getDeclaringClass().equals(remoteConnectionClass)) { | |
continue; | |
} | |
if (!Modifier.isPublic(method.getModifiers())) { | |
continue; | |
} | |
String name = method.getName(); | |
if (namesToExclude != null && namesToExclude.contains(name)) { | |
continue; | |
} | |
methods.add(method); | |
Class[] types = method.getParameterTypes(); | |
Object[] params = new Object[types.length]; | |
for (int j = 0; j < types.length; j++) { | |
Class type = types[j]; | |
if (type.isPrimitive()) { | |
params[j] = getWrapperClassInstance(type); | |
} | |
} | |
args.add(params); | |
} | |
} | |
protected void setKnownBugs() { | |
knownBugs = new Hashtable(); | |
if (generator.getMode() == TransporterGenerator.SET_EXCEPTION_INTO_TRANSPORTER) { | |
for (int i = 0; i < methods.size(); i++) { | |
Method method = (Method)methods.elementAt(i); | |
Object[] params = (Object[])args.elementAt(i); | |
String name = method.getName(); | |
if (name.equals("cursorSelectObjects")) { | |
if (params.length == 2) { | |
knownBugs.put(method, "bug 2909926"); | |
} | |
} | |
} | |
} | |
} | |
protected String getNameToBind() { | |
return this.getClass().getName(); | |
} | |
protected boolean isCorrect(int i) { | |
Throwable exception = exceptions[i]; | |
boolean ok; | |
int mode = generator.getMode(); | |
if (mode == TransporterGenerator.THROW_REMOTE_EXCEPTION) { | |
ok = exception != null; | |
if (ok) { | |
ok = CommunicationException.class.isInstance(exception); | |
if (ok) { | |
ok = | |
((CommunicationException)exception).getErrorCode() == CommunicationException.ERROR_IN_INVOCATION; | |
} | |
} | |
if (!ok) { | |
if (((Method)methods.elementAt(i)).getName().equals("isConnected")) { | |
if (Boolean.class.isInstance(results[i])) { | |
ok = !((Boolean)results[i]).booleanValue(); | |
} | |
} | |
} | |
} else if (mode == TransporterGenerator.SET_EXCEPTION_INTO_TRANSPORTER) { | |
ok = exception != null; | |
if (ok) { | |
ok = TestException.class.isInstance(exception); | |
if (ok) { | |
ok = ((TestException)exception).getMessage().endsWith(generator.getMessage()); | |
} | |
} | |
} else { | |
throw new TestException("Unsupported mode"); | |
} | |
return ok; | |
} | |
public void test() throws Exception { | |
results = new Object[methods.size()]; | |
exceptions = new Throwable[methods.size()]; | |
for (int i = 0; i < methods.size(); i++) { | |
Method method = (Method)methods.elementAt(i); | |
Object[] params = (Object[])args.elementAt(i); | |
Object result = null; | |
Throwable exception = null; | |
try { | |
result = method.invoke(getRemoteConnection(), params); | |
} catch (InvocationTargetException ex) { | |
exception = ex.getTargetException(); | |
} | |
results[i] = result; | |
exceptions[i] = exception; | |
} | |
} | |
public void verify() { | |
boolean errorHasOccured = false; | |
String errorMessage = new String("Wrong exception/result thrown/returned by methods:"); | |
String unknownBug = new String("!!!UNKNOWN BUG!!!"); | |
for (int i = 0; i < methods.size(); i++) { | |
Method method = (Method)methods.elementAt(i); | |
String name = method.getName(); | |
if (!isCorrect(i)) { | |
errorHasOccured = true; | |
errorMessage = errorMessage.concat(" "); | |
errorMessage = errorMessage.concat(name); | |
errorMessage = errorMessage.concat("("); | |
String bug = unknownBug; | |
if (knownBugs != null && !knownBugs.isEmpty()) { | |
String knownBug = (String)knownBugs.get(methods.elementAt(i)); | |
if (knownBug != null) { | |
bug = knownBug; | |
} | |
} | |
errorMessage = errorMessage.concat(bug); | |
errorMessage = errorMessage.concat(")"); | |
errorMessage = errorMessage.concat(";"); | |
} | |
} | |
if (errorHasOccured) { | |
throw new TestErrorException(errorMessage); | |
} | |
} | |
public static Object getWrapperClassInstance(Class cls) { | |
if (Integer.TYPE.equals(cls)) { | |
return new Integer(0); | |
} else if (Boolean.TYPE.equals(cls)) { | |
return new Boolean(false); | |
} else if (Character.TYPE.equals(cls)) { | |
return new Character(' '); | |
} else if (Byte.TYPE.equals(cls)) { | |
byte b = 0; | |
return new Byte(b); | |
} else if (Short.TYPE.equals(cls)) { | |
short s = 0; | |
return new Short(s); | |
} else if (Long.TYPE.equals(cls)) { | |
return new Long(0); | |
} else if (Float.TYPE.equals(cls)) { | |
return new Float(0); | |
} else if (Double.TYPE.equals(cls)) { | |
return new Double(0); | |
} else { | |
return null; | |
} | |
} | |
} |