@Override public <T> void visitCtLiteral(CtLiteral<T> e) { final CtLiteral peek = (CtLiteral) this.other; if (e.getValue() == null) { if (peek.getValue() != null) { setNotEqual(CtRole.VALUE); } } else if (peek.getValue() == null) { setNotEqual(CtRole.VALUE); } else if (!e.getValue().equals(peek.getValue())) { setNotEqual(CtRole.VALUE); } super.visitCtLiteral(e); }
public <T> void visitCtLiteral(final spoon.reflect.code.CtLiteral<T> literal) { spoon.reflect.code.CtLiteral<T> aCtLiteral = literal.getFactory().Core().createLiteral(); this.builder.copy(literal, aCtLiteral); aCtLiteral.setAnnotations(this.cloneHelper.clone(literal.getAnnotations())); aCtLiteral.setType(this.cloneHelper.clone(literal.getType())); aCtLiteral.setTypeCasts(this.cloneHelper.clone(literal.getTypeCasts())); aCtLiteral.setComments(this.cloneHelper.clone(literal.getComments())); this.cloneHelper.tailor(literal, aCtLiteral); this.other = aCtLiteral; }
public <T> void visitCtLiteral(final spoon.reflect.code.CtLiteral<T> literal) { spoon.reflect.code.CtLiteral other = ((spoon.reflect.code.CtLiteral) (this.stack.peek())); enter(literal); biScan(spoon.reflect.path.CtRole.ANNOTATION, literal.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, literal.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.CAST, literal.getTypeCasts(), other.getTypeCasts()); biScan(spoon.reflect.path.CtRole.COMMENT, literal.getComments(), other.getComments()); exit(literal); }
@Override public <T, U> void setValue(T element, U value) { castTarget(element).setValue(castValue(value)); } }
private CtMethod<?> createBooleanMutant(CtMethod test, CtLiteral booleanLiteral) { Boolean value = (Boolean) booleanLiteral.getValue(); CtMethod cloned_method = CloneHelper.cloneTestMethodForAmp(test, "_literalMutationBoolean"); CtLiteral newValue = cloned_method.getElements(new TypeFilter<CtLiteral>(CtLiteral.class) { @Override public boolean matches(CtLiteral element) { return element.equals(booleanLiteral); } }).get(0); newValue.setValue(!value); newValue.setTypeCasts(booleanLiteral.getTypeCasts()); Counter.updateInputOf(cloned_method, 1); DSpotUtils.addComment(newValue, "TestDataMutator on boolean", CtComment.CommentType.INLINE); return cloned_method; }
public <T> void visitCtLiteral(CtLiteral<T> literal) { enter(literal); scan(literal.getAnnotations()); scan(literal.getType()); scanReferences(literal.getTypeCasts()); T value = literal.getValue(); if (value instanceof CtReference) scan((CtReference) value); exit(literal); }
/** * Creates a literal with a given value. * * @param <T> * the type of the literal * @param value * the value of the literal * @return a new literal */ public <T> CtLiteral<T> createLiteral(T value) { CtLiteral<T> literal = factory.Core().<T>createLiteral(); literal.setValue(value); if (value != null) { literal.setType((CtTypeReference<T>) factory.Type().<T>createReference((Class<T>) value.getClass()).unbox()); } else { literal.setType((CtTypeReference<T>) factory.Type().nullType()); } return literal; }
if (newLiteral.getValue() instanceof Integer) { newLiteral.setValue(newValue.intValue()); } else if (newLiteral.getValue() instanceof Long) { newLiteral.setValue(newValue.longValue()); } else if (newLiteral.getValue() instanceof Double) { newLiteral.setValue(newValue.doubleValue()); } else if (newLiteral.getValue() instanceof Short) { newLiteral.setValue(newValue.shortValue()); } else if (newLiteral.getValue() instanceof Float) { newLiteral.setValue(newValue.floatValue()); } else if (newLiteral.getValue() instanceof Byte) { newLiteral.setValue(newValue.byteValue()); if (newLiteral.getParent() instanceof CtUnaryOperator) { CtUnaryOperator parent = (CtUnaryOperator) newLiteral.getParent(); if (parent.getKind().equals(UnaryOperatorKind.NEG)) { toReplace = parent;
@Override public boolean isToBeProcessed(CtLiteral candidate) { CtMethod parent = candidate.getParent(CtMethod.class); Object value = candidate.getValue(); if (parent == null) { return false; } else if (value instanceof Boolean || value == null) { return false; } return (this.buggyMethod == null || parent.getSimpleName().equals(this.buggyMethod)) && Number.class.isAssignableFrom(value.getClass()); }
public List<Transformation> process(ModificationPoint modificationPoint, LiteralPlaceholder literalPlaceholder) { List<Transformation> transformation = new ArrayList<>(); /// List<Ingredient> ingredients = getSpace(modificationPoint.getProgramVariant()) .getIngredients(modificationPoint.getCodeElement()); logger.debug("Ingredients lit (" + ingredients.size() + ") " + ingredients); // logger.debug("Placeholder vars "+ // varplaceholder.getPalceholders().keySet().size()); for (Ingredient ctCodeElement : ingredients) { CtLiteral literal4Space = (CtLiteral) ctCodeElement.getCode(); if (literal4Space.getType().isSubtypeOf(literalPlaceholder.getAffected().getType())) { Transformation t = new LiteralTransformation(literalPlaceholder, literalPlaceholder.getAffected(), literal4Space.getValue()); transformation.add(t); } } return transformation; }
if (literal.getValue() == null) { return "null"; } else if (literal.getValue() instanceof Long) { return literal.getValue() + "L"; } else if (literal.getValue() instanceof Float) { return literal.getValue() + "F"; } else if (literal.getValue() instanceof Character) { SourcePosition position = literal.getPosition(); if (position.isValidPosition()) { appendCharLiteral(sb, (Character) literal.getValue(), mayContainsSpecialCharacter); sb.append('\''); return sb.toString(); } else if (literal.getValue() instanceof String) { boolean mayContainsSpecialCharacters = true; SourcePosition position = literal.getPosition(); if (position.isValidPosition()) { mayContainsSpecialCharacters = ((String) literal.getValue()).length() != stringLength; return "\"" + getStringLiteral((String) literal.getValue(), mayContainsSpecialCharacters) + "\""; } else if (literal.getValue() instanceof Class) { return ((Class<?>) literal.getValue()).getName(); } else { return literal.getValue().toString();
@Override public void revert() { newLiteral.replace(previousVariable); }
@Override public <T> void visitCtLiteral(CtLiteral<T> literal) { super.visitCtLiteral(literal); if (!literalsValues.contains(literal) && !"String".equals(literal.getType().getSimpleName())) literalsValues.add(literal); }
public List<Transformation> process(ModificationPoint modificationPoint, VarLiPlaceholder varLiPlaceholder) { List<Transformation> transformation = new ArrayList<>(); List<Ingredient> ingredients = getSpace(modificationPoint.getProgramVariant()) .getIngredients(modificationPoint.getCodeElement()); logger.debug("Ingredients lit (" + ingredients.size() + ") " + ingredients); for (Ingredient ctCodeElement : ingredients) { CtLiteral literal4Space = (CtLiteral) ctCodeElement.getCode(); if (literal4Space.getType().isSubtypeOf(varLiPlaceholder.getAffectedVariable().getType())) { Transformation t = new VarLiTransformation(varLiPlaceholder, varLiPlaceholder.getAffectedVariable(), literal4Space.clone()); transformation.add(t); } } return transformation; }
public static boolean isCase(CtLiteral literal) { return literal.getParent(CtCase.class) != null; }
@Override public <T> CtLiteral<T> createLiteral() { CtLiteral<T> e = new CtLiteralImpl<>(); e.setFactory(getMainFactory()); return e; }
public <T> void visitCtLiteral(CtLiteral<T> literal) { setResult(literal.getFactory().Core().clone(literal)); }
/** * Creates a one-dimension array that must only contain literals. */ @SuppressWarnings("unchecked") public <T> CtNewArray<T[]> createLiteralArray(T[] value) { if (!value.getClass().isArray()) { throw new RuntimeException("value is not an array"); } if (value.getClass().getComponentType().isArray()) { throw new RuntimeException("can only create one-dimension arrays"); } final CtTypeReference<T> componentTypeRef = factory.Type().createReference((Class<T>) value.getClass().getComponentType()); final CtArrayTypeReference<T[]> arrayReference = factory.Type().createArrayReference(componentTypeRef); CtNewArray<T[]> array = factory.Core().<T[]>createNewArray().setType(arrayReference); for (T e : value) { CtLiteral<T> l = factory.Core().createLiteral(); l.setValue(e); array.addElement(l); } return array; }
public <T> void visitCtLiteral(final CtLiteral<T> literal) { enter(literal); scan(CtRole.ANNOTATION, literal.getAnnotations()); scan(CtRole.TYPE, literal.getType()); scan(CtRole.CAST, literal.getTypeCasts()); scan(CtRole.COMMENT, literal.getComments()); exit(literal); }