Examples with StringValue org.evosuite.symbolic.expr.str.StringValue used on opensource projects

Example 1 with StringValue

use of org.evosuite.symbolic.expr.str.StringValue in project evosuite by EvoSuite.

the class SymbolicObserver method readStaticField.

private ReferenceExpressionPair readStaticField(Field field) {
    String owner = field.getDeclaringClass().getName().replace('.', '/');
    String name = field.getName();
    Class<?> fieldClazz = field.getType();
    try {
        if (fieldClazz.equals(int.class)) {
            int conc_value = field.getInt(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newIntegerRef = newIntegerReference(conc_value, expr);
            return new ReferenceExpressionPair(newIntegerRef, expr);
        } else if (fieldClazz.equals(char.class)) {
            char conc_value = field.getChar(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newCharacterRef = newCharacterReference(conc_value, expr);
            return new ReferenceExpressionPair(newCharacterRef, expr);
        } else if (fieldClazz.equals(long.class)) {
            long conc_value = field.getLong(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newLongRef = newLongReference(conc_value, expr);
            return new ReferenceExpressionPair(newLongRef, expr);
        } else if (fieldClazz.equals(short.class)) {
            short conc_value = field.getShort(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newShortRef = newShortReference(conc_value, expr);
            return new ReferenceExpressionPair(newShortRef, expr);
        } else if (fieldClazz.equals(byte.class)) {
            byte conc_value = field.getByte(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newByteRef = newByteReference(conc_value, expr);
            return new ReferenceExpressionPair(newByteRef, expr);
        } else if (fieldClazz.equals(boolean.class)) {
            boolean conc_value = field.getBoolean(null);
            IntegerValue expr = env.heap.getStaticField(owner, name, conc_value ? 1 : 0);
            ReferenceConstant newBooleanRef = newBooleanReference(conc_value, expr);
            return new ReferenceExpressionPair(newBooleanRef, expr);
        } else if (fieldClazz.equals(float.class)) {
            float conc_value = field.getFloat(null);
            RealValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newFloatRef = newFloatReference(conc_value, expr);
            return new ReferenceExpressionPair(newFloatRef, expr);
        } else if (fieldClazz.equals(double.class)) {
            double conc_value = field.getDouble(null);
            RealValue expr = env.heap.getStaticField(owner, name, conc_value);
            ReferenceConstant newDoubleRef = newDoubleReference(conc_value, expr);
            return new ReferenceExpressionPair(newDoubleRef, expr);
        } else {
            Object conc_value = field.get(null);
            if (conc_value instanceof String) {
                String string = (String) conc_value;
                StringValue expr = env.heap.getStaticField(owner, name, string);
                ReferenceConstant newStringRef = newStringReference(string, expr);
                return new ReferenceExpressionPair(newStringRef, expr);
            } else {
                ReferenceExpression ref = env.heap.getReference(conc_value);
                if (conc_value != null && isWrapper(conc_value)) {
                    ReferenceConstant nonNullRef = (ReferenceConstant) ref;
                    Expression<?> expr = findOrCreate(conc_value, nonNullRef);
                    return new ReferenceExpressionPair(ref, expr);
                } else {
                    return new ReferenceExpressionPair(ref, null);
                }
            }
        }
    } catch (IllegalArgumentException e) {
        throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

Example 2 with StringValue

use of org.evosuite.symbolic.expr.str.StringValue in project evosuite by EvoSuite.

the class SymbolicObserver method after.

private void after(FunctionalMockStatement statement, Scope scope) {
    Type returnType = Type.getType(statement.getReturnClass());
    VariableReference varRef = statement.getReturnValue();
    String varName = varRef.getName();
    try {
        if (varRef.getType().equals(void.class)) {
        } else if (returnType.equals(Type.INT_TYPE) || returnType.equals(Type.BOOLEAN_TYPE) || returnType.equals(Type.DOUBLE_TYPE) || returnType.equals(Type.FLOAT_TYPE) || returnType.equals(Type.LONG_TYPE) || returnType.equals(Type.SHORT_TYPE) || returnType.equals(Type.BYTE_TYPE) || returnType.equals(Type.CHAR_TYPE)) {
            throw new EvosuiteError("mocking of primitive types is not supported!");
        } else {
            Object res = varRef.getObject(scope);
            ReferenceExpression ref = env.heap.getReference(res);
            if (res != null && res instanceof String) {
                String string = (String) res;
                ReferenceConstant newStringRef = (ReferenceConstant) env.heap.getReference(string);
                StringValue str_expr = env.heap.getField(Types.JAVA_LANG_STRING, SymbolicHeap.$STRING_VALUE, string, newStringRef, string);
                symb_references.put(varName, newStringRef);
                symb_expressions.put(varName, str_expr);
            } else {
                symb_references.put(varName, ref);
                if (res != null && isWrapper(res)) {
                    ReferenceConstant nonNullRef = (ReferenceConstant) ref;
                    Expression<?> expr = findOrCreate(res, nonNullRef);
                    symb_expressions.put(varName, expr);
                }
            }
        }
    } catch (CodeUnderTestException e) {
        throw new RuntimeException(e);
    }
}

Example 3 with StringValue

use of org.evosuite.symbolic.expr.str.StringValue in project evosuite by EvoSuite.

the class SymbolicObserver method readArray.

private ReferenceExpressionPair readArray(ArrayIndex rhs, Scope scope) {
    ArrayReference arrayReference = rhs.getArray();
    ReferenceConstant symb_array = (ReferenceConstant) symb_references.get(arrayReference.getName());
    int conc_index = rhs.getArrayIndex();
    Class<?> componentClass = arrayReference.getComponentClass();
    try {
        Object conc_array = arrayReference.getObject(scope);
        if (componentClass.equals(int.class)) {
            int conc_value = Array.getInt(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newIntegerRef = newIntegerReference(conc_value, expr);
            return new ReferenceExpressionPair(newIntegerRef, expr);
        } else if (componentClass.equals(char.class)) {
            char conc_value = Array.getChar(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newCharacterRef = newCharacterReference(conc_value, expr);
            return new ReferenceExpressionPair(newCharacterRef, expr);
        } else if (componentClass.equals(boolean.class)) {
            boolean conc_value = Array.getBoolean(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value ? 1 : 0);
            ReferenceConstant newBooleanRef = newBooleanReference(conc_value, expr);
            return new ReferenceExpressionPair(newBooleanRef, expr);
        } else if (componentClass.equals(byte.class)) {
            byte conc_value = Array.getByte(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newByteRef = newByteReference(conc_value, expr);
            return new ReferenceExpressionPair(newByteRef, expr);
        } else if (componentClass.equals(short.class)) {
            short conc_value = Array.getShort(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newShortRef = newShortReference(conc_value, expr);
            return new ReferenceExpressionPair(newShortRef, expr);
        } else if (componentClass.equals(long.class)) {
            long conc_value = Array.getLong(conc_array, conc_index);
            IntegerValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newLongRef = newLongReference(conc_value, expr);
            return new ReferenceExpressionPair(newLongRef, expr);
        } else if (componentClass.equals(float.class)) {
            float conc_value = Array.getFloat(conc_array, conc_index);
            RealValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newFloatRef = newFloatReference(conc_value, expr);
            return new ReferenceExpressionPair(newFloatRef, expr);
        } else if (componentClass.equals(double.class)) {
            double conc_value = Array.getDouble(conc_array, conc_index);
            RealValue expr = env.heap.array_load(symb_array, conc_index, conc_value);
            ReferenceConstant newDoubleRef = newDoubleReference(conc_value, expr);
            return new ReferenceExpressionPair(newDoubleRef, expr);
        } else {
            Object conc_value = Array.get(conc_array, conc_index);
            if (conc_value instanceof String) {
                StringValue expr = env.heap.array_load(symb_array, conc_index, (String) conc_value);
                ReferenceConstant newStringRef = newStringReference((String) conc_value, expr);
                return new ReferenceExpressionPair(newStringRef, expr);
            } else {
                ReferenceExpression ref = env.heap.getReference(conc_value);
                if (conc_value != null && isWrapper(conc_value)) {
                    ReferenceConstant nonNullRef = (ReferenceConstant) ref;
                    Expression<?> expr = findOrCreate(conc_value, nonNullRef);
                    return new ReferenceExpressionPair(ref, expr);
                } else {
                    return new ReferenceExpressionPair(ref, null);
                }
            }
        }
    } catch (CodeUnderTestException e) {
        throw new RuntimeException(e);
    }
}

Example 4 with StringValue

use of org.evosuite.symbolic.expr.str.StringValue in project evosuite by EvoSuite.

the class SymbolicObserver method after.

private void after(MethodStatement statement, Scope scope) {
    String owner = statement.getMethod().getDeclaringClass().getName().replace('.', '/');
    String name = statement.getMethod().getName();
    String desc = Type.getMethodDescriptor(statement.getMethod().getMethod());
    Type returnType = Type.getReturnType(statement.getMethod().getMethod());
    VariableReference varRef = statement.getReturnValue();
    String varName = varRef.getName();
    try {
        if (varRef.getType().equals(void.class)) {
            VM.CALL_RESULT(owner, name, desc);
        } else if (returnType.equals(Type.INT_TYPE)) {
            Integer res = (Integer) varRef.getObject(scope);
            VM.CALL_RESULT(res.intValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv32();
            ReferenceConstant newIntegerRef = newIntegerReference(res, intExpr);
            symb_references.put(varName, newIntegerRef);
            symb_expressions.put(varName, intExpr);
        } else if (returnType.equals(Type.BOOLEAN_TYPE)) {
            Boolean res = (Boolean) varRef.getObject(scope);
            VM.CALL_RESULT(res.booleanValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv32();
            ReferenceConstant newBooleanRef = newBooleanReference(res, intExpr);
            symb_references.put(varName, newBooleanRef);
            symb_expressions.put(varName, intExpr);
        } else if (returnType.equals(Type.DOUBLE_TYPE)) {
            Double res = (Double) varRef.getObject(scope);
            VM.CALL_RESULT(res.doubleValue(), owner, name, desc);
            RealValue realExpr = env.topFrame().operandStack.popFp64();
            ReferenceConstant newDoubleRef = newDoubleReference(res, realExpr);
            symb_references.put(varName, newDoubleRef);
            symb_expressions.put(varName, realExpr);
        } else if (returnType.equals(Type.FLOAT_TYPE)) {
            Float res = (Float) varRef.getObject(scope);
            VM.CALL_RESULT(res.floatValue(), owner, name, desc);
            RealValue realExpr = env.topFrame().operandStack.popFp32();
            ReferenceConstant newFloatRef = newFloatReference(res, realExpr);
            symb_references.put(varName, newFloatRef);
            symb_expressions.put(varName, realExpr);
        } else if (returnType.equals(Type.LONG_TYPE)) {
            Long res = (Long) varRef.getObject(scope);
            VM.CALL_RESULT(res.longValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv64();
            ReferenceConstant newBooleanRef = newLongReference(res, intExpr);
            symb_references.put(varName, newBooleanRef);
            symb_expressions.put(varName, intExpr);
        } else if (returnType.equals(Type.SHORT_TYPE)) {
            Short res = (Short) varRef.getObject(scope);
            VM.CALL_RESULT(res.shortValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv32();
            ReferenceConstant newShortRef = newShortReference(res, intExpr);
            symb_references.put(varName, newShortRef);
            symb_expressions.put(varName, intExpr);
        } else if (returnType.equals(Type.BYTE_TYPE)) {
            Byte res = (Byte) varRef.getObject(scope);
            VM.CALL_RESULT(res.byteValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv32();
            ReferenceConstant newByteRef = newByteReference(res, intExpr);
            symb_references.put(varName, newByteRef);
            symb_expressions.put(varName, intExpr);
        } else if (returnType.equals(Type.CHAR_TYPE)) {
            Character res = (Character) varRef.getObject(scope);
            VM.CALL_RESULT(res.charValue(), owner, name, desc);
            IntegerValue intExpr = env.topFrame().operandStack.popBv32();
            ReferenceConstant newCharacterRef = newCharacterReference(res, intExpr);
            symb_references.put(varName, newCharacterRef);
            symb_expressions.put(varName, intExpr);
        } else {
            Object res = varRef.getObject(scope);
            VM.CALL_RESULT(res, owner, name, desc);
            ReferenceExpression ref = env.topFrame().operandStack.peekRef();
            if (res != null && res instanceof String) {
                String string = (String) res;
                ReferenceConstant newStringRef = (ReferenceConstant) env.heap.getReference(string);
                StringValue str_expr = env.heap.getField(Types.JAVA_LANG_STRING, SymbolicHeap.$STRING_VALUE, string, newStringRef, string);
                symb_references.put(varName, newStringRef);
                symb_expressions.put(varName, str_expr);
            } else {
                symb_references.put(varName, ref);
                if (res != null && isWrapper(res)) {
                    ReferenceConstant nonNullRef = (ReferenceConstant) ref;
                    Expression<?> expr = findOrCreate(res, nonNullRef);
                    symb_expressions.put(varName, expr);
                }
            }
        }
    } catch (CodeUnderTestException e) {
        throw new RuntimeException(e);
    }
    // dispose all other arguments
    env.topFrame().operandStack.clearOperands();
}

Example 5 with StringValue

use of org.evosuite.symbolic.expr.str.StringValue in project evosuite by EvoSuite.

the class SymbolicHeap method array_load.

public StringValue array_load(ReferenceExpression symb_array, int conc_index, String conc_value) {
    Map<Integer, Expression<?>> symb_array_contents = getOrCreateSymbolicArray(symb_array);
    StringValue symb_value = (StringValue) symb_array_contents.get(conc_index);
    if (symb_value == null || !((String) symb_value.getConcreteValue()).equals(conc_value)) {
        symb_value = ExpressionFactory.buildNewStringConstant(conc_value);
        symb_array_contents.remove(conc_index);
    }
    return symb_value;
}