/*******************************************************************************
* Licensed 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 org.apache.kato.tests.junit;
import java.util.Iterator;
import java.util.List;
import javax.tools.diagnostics.image.CorruptData;
import javax.tools.diagnostics.image.CorruptDataException;
import javax.tools.diagnostics.image.DataUnavailable;
import javax.tools.diagnostics.image.Image;
import javax.tools.diagnostics.image.ImageAddressSpace;
import javax.tools.diagnostics.image.ImageFactory;
import javax.tools.diagnostics.image.ImageModule;
import javax.tools.diagnostics.image.ImageProcess;
import javax.tools.diagnostics.image.ImageThread;
import javax.tools.diagnostics.runtime.java.JavaClass;
import javax.tools.diagnostics.runtime.java.JavaClassLoader;
import javax.tools.diagnostics.runtime.java.JavaHeap;
import javax.tools.diagnostics.runtime.java.JavaMethod;
import javax.tools.diagnostics.runtime.java.JavaObject;
import javax.tools.diagnostics.runtime.java.JavaRuntime;
import javax.tools.diagnostics.runtime.java.JavaThread;
import org.apache.kato.tck.harness.TCKProcessTestcase;
import org.apache.kato.tests.junit.ImageLoaderHelper.Capabilities;
public abstract class AbstractImageTestcase extends TCKProcessTestcase {
private static Capabilities capabilities = null;
public ImageProcess defaultImageProcess() {
if(_proc==null) _proc= defaultAddressSpace().getCurrentProcess();
return _proc;
}
public ImageAddressSpace defaultAddressSpace() {
Image image = defaultTestingImage();
//TODO: come up with a good way to test each address space. For now we will just grab the first one
return (ImageAddressSpace) image.getAddressSpaces().get(0);
}
/**
* Returns the Image for testing, creating it if necessary
* @return The default testing image
*/
public Image defaultTestingImage() {
try {
if (null == capabilities) {
capabilities=new ImageLoaderHelper().getCapabilities();
}
} catch (Throwable t) {
t.printStackTrace();
fail();
}
return capabilities.image;
}
private ImageProcess _proc = null;
private ImageModule _module = null;
public ImageModule defaultImageModule() {
if(_module!=null) return _module;
ImageProcess proc = defaultImageProcess();
List it = null;
try {
it = proc.getLibraries();
} catch (DataUnavailable e) {
//ok
} catch (CorruptDataException e) {
//ok
}
if (null == it) {
//we have nothing to test so throw unimplemented so we know it isn't a real bug
throw new TestNotImplementedException();
}
_module=(ImageModule) it.get(0);
return _module;
}
public ImageFactory getFactory() {
return capabilities.factory;
}
public JavaRuntime defaultJavaRuntime() {
JavaRuntime runtime = null;
Iterator it = defaultImageProcess().getRuntimes().iterator();
assertFalse(null == it);
while ((null == runtime) && (it.hasNext())) {
Object maybeRuntime = it.next();
if (maybeRuntime instanceof JavaRuntime) {
runtime = (JavaRuntime) maybeRuntime;
} else {
throw new TestNotImplementedException();
}
}
assertNotNull(runtime);
return runtime;
}
public JavaThread defaultJavaThread() {
JavaRuntime time = defaultJavaRuntime();
assertNotNull(time);
Iterator it = time.getThreads().iterator();
assertNotNull(it);
assertTrue(it.hasNext());
//threads without stack frames aren't very useful for testing so ignore them
// unless they are the only ones
JavaThread candidate = null;
do {
candidate = (JavaThread) it.next();
} while ((it.hasNext()) && (!candidate.getStackFrames().iterator().hasNext()));
return candidate;
}
public JavaClassLoader defaultJavaClassLoader() {
Iterator loaders = defaultJavaRuntime().getJavaClassLoaders().iterator();
assertTrue(loaders.hasNext());
JavaClassLoader loader = (JavaClassLoader) loaders.next();
Iterator i=loader.getDefinedClasses().iterator();
while ((!i.hasNext()) && (loaders.hasNext())) {
loader = (JavaClassLoader) loaders.next();
}
return loader;
}
public JavaClass defaultJavaClass() {
// Choose a class loader
JavaClassLoader loader = defaultJavaClassLoader();
// Choose a class which has a superclass
try {
for (Iterator iter = loader.getDefinedClasses().iterator(); iter.hasNext();) {
JavaClass clazz = (JavaClass) iter.next();
if ( !clazz.getName().equals("java/lang/Object") &&
!clazz.getName().equals("boolean" ) &&
!clazz.getName().equals("byte" ) &&
!clazz.getName().equals("char" ) &&
!clazz.getName().equals("double" ) &&
!clazz.getName().equals("float" ) &&
!clazz.getName().equals("int" ) &&
!clazz.getName().equals("long" ) &&
!clazz.getName().equals("short" ) &&
!clazz.getName().equals("void" ) &&
!clazz.isArray() ) {
return clazz;
}
}
} catch (CorruptDataException e) {
//allowed by the spec
} catch (Exception e) {
//if we caught anything else, this is an error
fail();
}
return null;
}
public JavaHeap defaultJavaHeap() {
JavaRuntime runtime = defaultJavaRuntime();
Iterator it = runtime.getHeaps().iterator();
assertNotNull(it);
assertTrue(it.hasNext());
JavaHeap heap = (JavaHeap) it.next();
// This should use Middleware Heap as default
// move on to Middleware Heap
if (heap.getName().equalsIgnoreCase("System Heap")){
heap = (JavaHeap) it.next();
if (heap.getName().equalsIgnoreCase("Transient Heap")){
heap = (JavaHeap) it.next();
}
}
return (JavaHeap) heap;
}
public JavaObject defaultJavaObject(boolean isArray) {
JavaObject foundObject = null;
JavaHeap heap = defaultJavaHeap();
Iterator objects = heap.getObjects().iterator();
while ((null == foundObject) && (objects.hasNext())) {
JavaObject oneObject = (JavaObject) objects.next();
try {
if (isArray) {
// We need any array object with at least one element
if (oneObject.isArray()) {
if (oneObject.getArraySize() > 0) {
foundObject = oneObject;
}
}
} else {
// We need a non-array, non-trivial object with at least two declared fields
if ( (!oneObject.isArray()) && (!oneObject.getJavaClass().getName().equals("java/lang/Object"))) {
Iterator declaredFields=oneObject.getJavaClass().getDeclaredFields().iterator();
if (declaredFields.hasNext()) {
declaredFields.next();
if (declaredFields.hasNext()) {
foundObject = oneObject;
}
}
}
}
} catch (CorruptDataException e) {
//just ignore this one
}
}
return foundObject;
}
public ImageThread defaultImageThread() {
Iterator it = defaultImageProcess().getThreads().iterator();
assertNotNull(it);
assertTrue(it.hasNext());
ImageThread thread = null;
while (null == thread && it.hasNext()) {
Object next = it.next();
if (next instanceof CorruptData)
continue;
thread = (ImageThread) next;
}
if (null == thread)
throw new TestNotImplementedException();
return thread;
}
public JavaMethod defaultJavaMethod() {
JavaRuntime runtime = defaultJavaRuntime();
Iterator it = runtime.getCompiledMethods().iterator();
if (it.hasNext()) {
return (JavaMethod) it.next();
} else {
System.err.println("Warning: No compiled methods found! This core must have been without JIT!");
throw new TestNotImplementedException();
}
}
protected void setUp() throws Exception {
if(capabilities==null) capabilities=new ImageLoaderHelper().getCapabilities();
}
}