Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/**
* Copyright (C) 2010-2018 Gordon Fraser, Andrea Arcuri and EvoSuite
* contributors
*
* This file is part of EvoSuite.
*
* EvoSuite is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, either version 3.0 of the License, or
* (at your option) any later version.
*
* EvoSuite is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with EvoSuite. If not, see .
*/
package org.evosuite.regression;
import org.apache.commons.lang3.ClassUtils;
import org.evosuite.testcase.execution.Scope;
import org.evosuite.testcase.variable.VariableReference;
import org.evosuite.utils.generic.GenericClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.management.RuntimeErrorException;
/**
* Implementation of object distance following
* "Object distance and its application to adaptive random testing of object-oriented programs"
* by Ilinca Ciupa, Andreas Leitner, Manuel Oriol, Bertrand Meyer (http://se.ethz.ch/~meyer/publications/testing/object_distance.pdf).
*
* We implemented the following changes:
*
*
In the paper if a reference field does not match (i.e., is different
* because the types are different) then R = 10 is used as difference. This does
* not make sense for several reasons:
*
*
The difference is already taken into account in the type distance.
*
If one type adds a field but the other does not, so what? R/2?
*
* Therefore we decided to apply the value R as factor in the type difference to
* the non-shared fields.
*
In the paper a factor of 1/2 is applied to the recursive distance. We
* treat the recursive distance simply as any other field distance, thus it is
* normalized by the number of fields and not by a static factor.
*
There is no distance given for two characters. We defined that to be C =
* 10.
*
*/
public class ObjectFields {
private static final double B = 10;
private static final double R = 10;
private static final double V = 10;
private static final double C = 10;
private static int MAX_RECURSION = 1;
/*
* public static double getObjectDistance(Object p, Object q) { double
* distance = new ObjectVariables().getObjectDistanceImpl(p, q); assert
* distance >= 0.0 : "Result was " + distance; assert
* !Double.isNaN(distance); assert !Double.isInfinite(distance); return
* distance; }
*/
private Scope scope;
public ObjectFields(Scope s) {
scope = s;
// getObjectVariables();
}
/*
* public static Object getObjectVariables(Object p) { Object distance = new
* ObjectVariables().getObjectValue(p); // assert distance >= 0.0 :
* "Result was " + distance; // assert !Double.isNaN(distance); // assert
* !Double.isInfinite(distance); return distance; }
*/
public List>> getObjectVariables(Object p,
Class c) {
List>> vars = getFieldValues(c, p);
// logger.warn("getObjectVariables: " + vars);
return vars;
}
private static Collection getAllFields(Class commonAncestor) {
Collection result = new ArrayList();
Class ancestor = commonAncestor;
while (!ancestor.equals(Object.class)) {
for (Field f : ancestor.getDeclaredFields()) {
if (Modifier.isFinal(f.getModifiers()))
continue;
if (Modifier.isStatic(f.getModifiers()))
continue;
result.add(f);
}
// result.addAll(Arrays.asList(ancestor.getDeclaredFields()));
ancestor = ancestor.getSuperclass();
}
return result;
}
/*
* private static Class getCommonAncestor(Object p) { double pInheritCnt
* = getTypeDistance(Object.class, p);
*
* Class pClass = p.getClass();
*
* while (!pClass.equals(qClass)) { if (pInheritCnt > qInheritCnt) { pClass
* = pClass.getSuperclass(); pInheritCnt--; } else { qClass =
* qClass.getSuperclass(); qInheritCnt--; } } return pClass; }
*/
private static boolean getElementaryValue(Boolean p) {
return p.booleanValue();
}
private static char getElementaryValue(Character p) {
return p.charValue();
}
private static double getElementaryValue(Number p) {
return p.doubleValue();
}
private static double getElementaryValue(Enum p) {
return p.ordinal();
}
private static String getElementaryValue(String p) {
return p;
}
private static Object getFieldValue(Field field, Object p) {
try {
/*Class objClass = p.getClass();
if(p instanceof java.lang.String){
((String) p).hashCode();
}*/
Class fieldType = field.getType();
field.setAccessible(true);
if (fieldType.isPrimitive()) {
if (fieldType.equals(Boolean.TYPE)) {
return field.getBoolean(p);
}
if (fieldType.equals(Integer.TYPE)) {
return field.getInt(p);
}
if (fieldType.equals(Byte.TYPE)) {
return field.getByte(p);
}
if (fieldType.equals(Short.TYPE)) {
return field.getShort(p);
}
if (fieldType.equals(Long.TYPE)) {
return field.getLong(p);
}
if (fieldType.equals(Double.TYPE)) {
return field.getDouble(p);
}
if (fieldType.equals(Float.TYPE)) {
return field.getFloat(p);
}
if (fieldType.equals(Character.TYPE)) {
return field.getChar(p);
}
throw new UnsupportedOperationException("Primitive type "
+ fieldType + " not implemented!");
}
return field.get(p);
} catch (IllegalAccessException exc) {
throw new RuntimeException(exc);
} catch (OutOfMemoryError e) {
e.printStackTrace();
if (MAX_RECURSION != 0)
MAX_RECURSION = 0;
else
throw new RuntimeErrorException(e);
return getFieldValue(field, p);
}
}
/*
* private static Integer getHasCode(Object p) { return ((p == null) ? 0 :
* p.hashCode()) ; }
*/
private static Collection getNonSharedFields(
Class commonAncestor, Object p) {
Collection result = new ArrayList();
Class ancestor = p.getClass();
while (!ancestor.equals(commonAncestor)) {
result.addAll(Arrays.asList(ancestor.getDeclaredFields()));
ancestor = ancestor.getSuperclass();
}
return result;
}
private static double getTypeDistance(Class commonAncestor, Object p) {
double result = 0.0;
Class ancestor = p.getClass();
while (!ancestor.equals(commonAncestor)) {
ancestor = ancestor.getSuperclass();
result++;
}
return result;
}
private static double getTypeDistance(Class commonAncestor, Object p,
Object q) {
double result = getTypeDistance(commonAncestor, p)
+ getTypeDistance(commonAncestor, q);
result += getNonSharedFields(commonAncestor, p).size() * R;
result += getNonSharedFields(commonAncestor, q).size() * R;
return result;
}
private final Map hashRecursionCntMap = new LinkedHashMap();
private final Map resultCache = new LinkedHashMap();
/*
* private boolean breakRecursion(Object p) { Integer hashCode =
* getHasCode(p); Integer recursionCnt = hashRecursionCntMap.get(hashCode);
* if (recursionCnt == null) { recursionCnt = 0; } if (recursionCnt >=
* MAX_RECURSION) { return true; } recursionCnt++;
* hashRecursionCntMap.put(hashCode, recursionCnt); return false; }
*/
/*
* private double getCompositeObjectValue(Object p) { Double cachedDistance
* = resultCache.get(getHasCode(p)); if (cachedDistance != null) { return
* cachedDistance; } if (breakRecursion(p)) { return 0.0; } Class
* commonAncestor = getCommonAncestor(p); double distance =
* getTypeDistance(commonAncestor, p); //distance +=
* getFieldDistance(commonAncestor, p); resultCache.put(getHasCode(p),
* distance); return distance; }
*/
public Map>> getObjectVariables() {
//List>> ov = new ArrayList>>();
//Map> variable_field = new HashMap>();
Map>> variable_ref_field = new HashMap>>();
//Map field_value = new HashMap();
// Collection fields = getAllFields(c);
//List
