How to use

CtLiteral

in

spoon.reflect.code

@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(spoon.reflect.code.CtLiteral<T> e) {
  ((spoon.reflect.code.CtLiteral<T>) (other)).setValue(e.getValue());
  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);
}