/*******************************************************************************
* 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.tck.scenario142.javaruntime;
import java.util.Iterator;
import javax.tools.diagnostics.runtime.java.JavaClass;
import javax.tools.diagnostics.runtime.java.JavaClassLoader;
import javax.tools.diagnostics.runtime.java.JavaObject;
import javax.tools.diagnostics.runtime.java.JavaReference;
import org.apache.kato.tck.harness.TCKJavaRuntimeTestcase;
public class TestJavaReferences extends TCKJavaRuntimeTestcase {
public void testReferences_getDescription() {
JavaObject thisObj = getScenerioReference();
Iterator references = thisObj.getReferences().iterator();
while (references.hasNext()) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
assertNotNull("Reference description is null", ref.getDescription());
}
}
public void testReferences_getReachability() throws Exception {
JavaObject thisObj = getScenerioReference();
Iterator references = thisObj.getReferences().iterator();
while (references.hasNext()) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
Object target = ref.getTarget();
if (!(target instanceof JavaObject)) {
continue;
}
JavaObject targetObject = (JavaObject)target;
if ("java/lang/ref/WeakReference".equals(targetObject.getJavaClass().getName())) {
JavaReference referent = getReferent(targetObject);
assertTrue("Reachability for weak referent different from \"Weak\"", JavaReference.REACHABILITY_WEAK == referent.getReachability());
} else if ("java/lang/ref/SoftReference".equals(targetObject.getJavaClass().getName())) {
JavaReference referent = getReferent(targetObject);
assertTrue("Reachability for soft referent different from \"Soft\"", JavaReference.REACHABILITY_SOFT == referent.getReachability());
} else if ("java/lang/ref/PhantomReference".equals(targetObject.getJavaClass().getName())) {
JavaReference referent = getReferent(targetObject);
assertTrue("Reachability for phantom referent different from \"Phantom\"", JavaReference.REACHABILITY_PHANTOM == referent.getReachability());
} else if (targetObject.getJavaClass().getName().endsWith("StrongReferent")) {
assertTrue("Reachability for strong field reference different from \"Strong\"", JavaReference.REACHABILITY_STRONG == ref.getReachability());
}
}
}
public void testReferences_isClassReference() throws Exception {
JavaObject thisObj = getScenerioReference();
Iterator references = thisObj.getReferences().iterator();
while (references.hasNext()) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
Object target = ref.getTarget();
if (ref.isClassReference()) {
assertTrue("Supposed class reference has a non-JavaClass target",target instanceof JavaClass);
}
}
}
public void testReferences_isObjectReference() throws Exception {
JavaObject thisObj = getScenerioReference();
Iterator references = thisObj.getReferences().iterator();
while (references.hasNext()) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
Object target = ref.getTarget();
if (ref.isObjectReference()) {
assertTrue("Supposed object reference has a non-JavaObject target",target instanceof JavaObject);
}
}
}
public void testReferences_getReferenceType() throws Exception {
JavaObject thisObj = getScenerioReference();
Iterator references = thisObj.getReferences().iterator();
while (references.hasNext()) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
int type = ref.getReferenceType();
Object source = ref.getSource();
Object target = ref.getTarget();
switch (type) {
case JavaReference.REFERENCE_FIELD:
if (source instanceof JavaObject) {
JavaObject sourceObject = (JavaObject)source;
if (!(sourceObject.equals(thisObj))) {
fail("Source object for a field reference not equal to this object.");
}
if (target instanceof JavaObject) {
JavaObject targetObject = (JavaObject)target;
String objectsClassName = targetObject.getJavaClass().getName();
if (!(objectsClassName.endsWith("Reference") ||
objectsClassName.endsWith("Referent") ||
objectsClassName.endsWith("ArrayElement;") ||
objectsClassName.endsWith("ClassLoader"))) {
fail("Unexpected field reference of type: "+ objectsClassName);
}
if (objectsClassName.endsWith("ArrayElement;") && targetObject.isArray()) {
//found the array field.
Iterator refs = targetObject.getReferences().iterator();
boolean arrayElementFound = false;
while (refs.hasNext()) {
Object next2 = refs.next();
if (!(next2 instanceof JavaReference)) {
continue;
}
JavaReference ref2 = (JavaReference)next2;
int type2 = ref2.getReferenceType();
Object target2 = ref2.getTarget();
if (type2 == JavaReference.REFERENCE_ARRAY_ELEMENT) {
if (target2 instanceof JavaObject) {
JavaObject targetObject2 = (JavaObject)target2;
String objectsClassName2 = targetObject2.getJavaClass().getName();
if (objectsClassName2.endsWith("ArrayElement") && !targetObject2.isArray()) {
arrayElementFound = true;
}
} else {
fail("Target object of a REFERENCE_ARRAY_ELEMENT reference has the wrong type.");
}
}
}
assertTrue("Array element reference not found.", arrayElementFound);
}
} else {
fail("Target object of a REFERENCE_ARRAY_ELEMENT reference has the wrong type.");
}
} else {
fail("Source object of a field reference is not a valid JavaObject.");
}
break;
case JavaReference.REFERENCE_CLASS:
if (source instanceof JavaObject) {
JavaObject sourceObject = (JavaObject)source;
if (!(sourceObject.equals(thisObj))) {
fail("Source object for a CLASS reference not equal to this object.");
}
if (!(target instanceof JavaClass)) {
fail("Target object for a CLASS reference not a JavaClass object.");
}
JavaClass targetClass = (JavaClass)target;
assertTrue("Target class for the CLASS reference of this object different from expected.", targetClass.getName().endsWith("SetupJavaReferences"));
Iterator refs = targetClass.getReferences().iterator();
boolean classLoaderFound = false;
while (refs.hasNext()) {
Object next2 = refs.next();
if (!(next2 instanceof JavaReference)) {
continue;
}
JavaReference ref2 = (JavaReference)next2;
int type2 = ref2.getReferenceType();
Object target2 = ref2.getTarget();
if (type2 == JavaReference.REFERENCE_CLASS_LOADER) {
if (!(target2 instanceof JavaObject)) {
fail("Target object for a CLASSLOADER reference does not represent a JavaObject.");
}
JavaObject targetObject2 = (JavaObject)target2;
if (targetObject2.getClass().getName().endsWith("ClassLoader")) {
fail("Target object for a CLASSLOADER reference does not represent a ClassLoader.");
} else {
classLoaderFound = true;
}
}
}
assertTrue("ClassLoader reference not found.", classLoaderFound);
} else {
fail("Source object of a CLASS reference is not a valid JavaObject.");
}
break;
case JavaReference.REFERENCE_CLASS_LOADER:
if (source instanceof JavaObject) {
JavaObject sourceObject = (JavaObject)source;
if (!(sourceObject.equals(thisObj))) {
fail("Source object for a CLASSLOADER reference not equal to this object.");
}
if (!(target instanceof JavaClassLoader)) {
fail("Target object for a CLASSLOADER reference not a JavaClass object.");
}
} else {
fail("Source object of a CLASS reference is not a valid JavaObject.");
}
break;
}
}
}
private JavaReference getReferent (JavaObject obj) {
Iterator references = obj.getReferences().iterator();
JavaReference referent = null;
while (references.hasNext() && referent == null) {
Object next = references.next();
if (!(next instanceof JavaReference)) {
continue;
}
JavaReference ref = (JavaReference)next;
String description = ref.getDescription();
if (description.indexOf("referent") == -1) {
continue;
}
referent = ref;
}
return referent;
}
}