diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/AbstractPrimitiveRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/AbstractPrimitiveRatherThanWrapperFinder.java
index 0f5cf6b..79ef2b1 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/AbstractPrimitiveRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/AbstractPrimitiveRatherThanWrapperFinder.java
@@ -22,6 +22,8 @@
 import org.eclipse.jdt.core.dom.Assignment;
 import org.eclipse.jdt.core.dom.Block;
 import org.eclipse.jdt.core.dom.CastExpression;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.core.dom.ConditionalExpression;
 import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.FieldAccess;
@@ -44,6 +46,7 @@
 import org.eclipse.jdt.internal.corext.dom.Bindings;
 import org.eclipse.jdt.internal.corext.dom.InterruptibleVisitor;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
+import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
 
 public abstract class AbstractPrimitiveRatherThanWrapperFinder extends ASTVisitor {
 	protected List<CompilationUnitRewriteOperation> fResult;
@@ -63,13 +66,6 @@
 	public abstract Class<? extends Expression> getLiteralClass();
 
 	/**
-	 * Refactor the wrapper.
-	 *
-	 * @param node the node
-	 */
-	public abstract void refactorWrapper(final VariableDeclarationStatement node);
-
-	/**
 	 * Get the wrapper fully qualified name.
 	 *
 	 * @return the wrapper fully qualified name.
@@ -162,22 +158,35 @@
 	}
 
 	@Override
-	public boolean visit(final VariableDeclarationStatement node) {
-		VariableDeclarationFragment fragment= ASTNodes.getUniqueFragment(node);
+	public boolean visit(final VariableDeclarationStatement visited) {
+		VariableDeclarationFragment fragment= ASTNodes.getUniqueFragment(visited);
 
 		if (fragment != null
-				&& (fragment.resolveBinding() != null && ASTNodes.hasType(fragment.resolveBinding().getType(), getWrapperFullyQualifiedName())
-						|| node.getType() != null && node.getType().resolveBinding() != null && ASTNodes.hasType(node.getType().resolveBinding(), getWrapperFullyQualifiedName()))
 				&& fragment.getInitializer() != null
-				&& isNotNull(fragment.getInitializer())) {
+				&& (isNotNull(fragment.getInitializer()) || canReturnPrimitiveInstead(fragment.getInitializer()))
+				&& (fragment.resolveBinding() != null && ASTNodes.hasType(fragment.resolveBinding().getType(), getWrapperFullyQualifiedName())
+						|| visited.getType() != null && visited.getType().resolveBinding() != null && ASTNodes.hasType(visited.getType().resolveBinding(), getWrapperFullyQualifiedName()))) {
 			VarOccurrenceVisitor varOccurrenceVisitor= new VarOccurrenceVisitor(fragment);
 			Block parentBlock= ASTNodes.getTypedAncestor(fragment, Block.class);
 
 			if (parentBlock != null) {
 				varOccurrenceVisitor.traverseNodeInterruptibly(parentBlock);
+				int boxingCount= varOccurrenceVisitor.getAutoBoxingCount();
 
-				if (varOccurrenceVisitor.isPrimitiveAllowed() && varOccurrenceVisitor.getAutoBoxingCount() < 2) {
-					refactorWrapper(node);
+				if (ASTNodes.hasType(fragment.getInitializer(), getWrapperFullyQualifiedName()) && !canReturnPrimitiveInstead(fragment.getInitializer())) {
+					boxingCount++;
+				}
+
+				if (varOccurrenceVisitor.isPrimitiveAllowed() && boxingCount < 2) {
+					fResult.add(new PrimitiveRatherThanWrapperOperation(
+							visited,
+							getPrimitiveTypeName(),
+							getWrapperFullyQualifiedName(),
+							fragment.getInitializer(),
+							varOccurrenceVisitor.getToStringMethods(),
+							varOccurrenceVisitor.getCompareToMethods(),
+							varOccurrenceVisitor.getPrimitiveValueMethods(),
+							getParsingMethodName(getWrapperFullyQualifiedName(), (CompilationUnit) visited.getRoot())));
 					return false;
 				}
 			}
@@ -230,16 +239,72 @@
 							&& isNotNull(castExpression.getExpression());
 		}
 
-		if (expression instanceof MethodInvocation) {
-			MethodInvocation methodInvocation= (MethodInvocation) expression;
-			return ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "valueOf", getPrimitiveTypeName()); //$NON-NLS-1$
+		if (expression instanceof ClassInstanceCreation) {
+			ClassInstanceCreation classInstanceCreation= (ClassInstanceCreation) expression;
+			List<Expression> classInstanceCreationArguments= classInstanceCreation.arguments();
+
+			if (classInstanceCreationArguments.size() == 1) {
+				Expression arg0= classInstanceCreationArguments.get(0);
+
+				return ASTNodes.hasType(arg0, String.class.getCanonicalName());
+			}
 		}
 
 		return false;
 	}
 
+	private boolean canReturnPrimitiveInstead(final Expression expression) {
+		MethodInvocation methodInvocation= ASTNodes.as(expression, MethodInvocation.class);
+
+		if (methodInvocation != null) {
+			return ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "valueOf", getPrimitiveTypeName()) //$NON-NLS-1$
+					|| getParsingMethodName(getWrapperFullyQualifiedName(), (CompilationUnit) expression.getRoot()) != null
+					&& (
+							ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "valueOf", String.class.getCanonicalName()) //$NON-NLS-1$
+							|| ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "valueOf", String.class.getCanonicalName(), int.class.getSimpleName()) //$NON-NLS-1$
+							);
+		}
+
+		return false;
+	}
+
+	private String getParsingMethodName(final String wrapperFullyQualifiedName, final CompilationUnit compilationUnit) {
+		if (Boolean.class.getCanonicalName().equals(wrapperFullyQualifiedName) && JavaModelUtil.is50OrHigher(compilationUnit.getJavaElement().getJavaProject())) {
+			return "parseBoolean"; //$NON-NLS-1$
+		}
+
+		if (Integer.class.getCanonicalName().equals(wrapperFullyQualifiedName)) {
+			return "parseInt"; //$NON-NLS-1$
+		}
+
+		if (Long.class.getCanonicalName().equals(wrapperFullyQualifiedName)) {
+			return "parseLong"; //$NON-NLS-1$
+		}
+
+		if (Double.class.getCanonicalName().equals(wrapperFullyQualifiedName) && JavaModelUtil.is1d2OrHigher(compilationUnit.getJavaElement().getJavaProject())) {
+			return "parseDouble"; //$NON-NLS-1$
+		}
+
+		if (Float.class.getCanonicalName().equals(wrapperFullyQualifiedName) && JavaModelUtil.is1d2OrHigher(compilationUnit.getJavaElement().getJavaProject())) {
+			return "parseFloat"; //$NON-NLS-1$
+		}
+
+		if (Short.class.getCanonicalName().equals(wrapperFullyQualifiedName)) {
+			return "parseShort"; //$NON-NLS-1$
+		}
+
+		if (Byte.class.getCanonicalName().equals(wrapperFullyQualifiedName)) {
+			return "parseByte"; //$NON-NLS-1$
+		}
+
+		return null;
+	}
+
 	private class VarOccurrenceVisitor extends InterruptibleVisitor {
 		private final VariableDeclarationFragment varDecl;
+		private final List<MethodInvocation> toStringMethods = new ArrayList<>();
+		private final List<MethodInvocation> compareToMethods = new ArrayList<>();
+		private final List<MethodInvocation> primitiveValueMethods = new ArrayList<>();
 		private boolean isPrimitiveAllowed= true;
 		private boolean isVarReturned;
 		private int autoBoxingCount;
@@ -248,6 +313,18 @@
 			varDecl= var;
 		}
 
+		public List<MethodInvocation> getToStringMethods() {
+			return toStringMethods;
+		}
+
+		public List<MethodInvocation> getCompareToMethods() {
+			return compareToMethods;
+		}
+
+		public List<MethodInvocation> getPrimitiveValueMethods() {
+			return primitiveValueMethods;
+		}
+
 		public boolean isPrimitiveAllowed() {
 			return isPrimitiveAllowed;
 		}
@@ -346,9 +423,36 @@
 			case ASTNode.POSTFIX_EXPRESSION:
 				return getPostfixOutSafeOperators().contains(((PostfixExpression) parentNode).getOperator());
 
+			case ASTNode.METHOD_INVOCATION:
+				MethodInvocation methodInvocation= (MethodInvocation) parentNode;
+
+				if (node.getLocationInParent() == MethodInvocation.EXPRESSION_PROPERTY) {
+					if (ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), getPrimitiveTypeName() + "Value")) { //$NON-NLS-1$
+						primitiveValueMethods.add(methodInvocation);
+						return true;
+					}
+
+					if (ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "toString")) { //$NON-NLS-1$
+						toStringMethods.add(methodInvocation);
+						return true;
+					}
+
+					if (ASTNodes.usesGivenSignature(methodInvocation, getWrapperFullyQualifiedName(), "compareTo", getWrapperFullyQualifiedName())) { //$NON-NLS-1$
+						if (ASTNodes.hasType((Expression) methodInvocation.arguments().get(0), getWrapperFullyQualifiedName())) {
+							autoBoxingCount++;
+						}
+
+						compareToMethods.add(methodInvocation);
+						return true;
+					}
+				}
+
+				break;
+
 			default:
-				return isSpecificPrimitiveAllowed(node);
 			}
+
+			return isSpecificPrimitiveAllowed(node);
 		}
 
 		private boolean isOfType(final ITypeBinding resolveTypeBinding) {
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveBooleanRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveBooleanRatherThanWrapperFinder.java
index 46f5ecd..25b6672 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveBooleanRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveBooleanRatherThanWrapperFinder.java
@@ -22,15 +22,11 @@
 import org.eclipse.jdt.core.dom.Expression;
 import org.eclipse.jdt.core.dom.InfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveBooleanRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveBooleanRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveBooleanRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -89,9 +85,4 @@
 			return false;
 		}
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.BOOLEAN));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveByteRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveByteRatherThanWrapperFinder.java
index 2856166..9aabd06 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveByteRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveByteRatherThanWrapperFinder.java
@@ -22,15 +22,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveByteRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveByteRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveByteRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -100,9 +96,4 @@
 			return false;
 		}
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.BYTE));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveCharRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveCharRatherThanWrapperFinder.java
index d2ed825..ba17c84 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveCharRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveCharRatherThanWrapperFinder.java
@@ -23,15 +23,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveCharRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveCharRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveCharRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -113,9 +109,4 @@
 			return false;
 		}
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.CHAR));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveDoubleRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveDoubleRatherThanWrapperFinder.java
index c66f638..9dcc0ac 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveDoubleRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveDoubleRatherThanWrapperFinder.java
@@ -22,15 +22,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveDoubleRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveDoubleRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveDoubleRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -94,9 +90,4 @@
 	public String[] getSafeInConstants() {
 		return new String[] { "MIN_VALUE", "MAX_VALUE", "MIN_NORMAL", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.DOUBLE));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveFloatRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveFloatRatherThanWrapperFinder.java
index cbb20bd..ed43f96 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveFloatRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveFloatRatherThanWrapperFinder.java
@@ -22,15 +22,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveFloatRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveFloatRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveFloatRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -92,9 +88,4 @@
 	public String[] getSafeInConstants() {
 		return new String[] { "MIN_VALUE", "MAX_VALUE", "MIN_NORMAL", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.FLOAT));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveIntRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveIntRatherThanWrapperFinder.java
index 3f4b262..a0f9297 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveIntRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveIntRatherThanWrapperFinder.java
@@ -23,15 +23,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveIntRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveIntRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveIntRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -114,9 +110,4 @@
 			return false;
 		}
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.INT));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveLongRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveLongRatherThanWrapperFinder.java
index 914ecf5..c835466 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveLongRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveLongRatherThanWrapperFinder.java
@@ -22,15 +22,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveLongRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveLongRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveLongRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -99,9 +95,4 @@
 	public String[] getSafeInConstants() {
 		return new String[] { "MIN_VALUE", "MAX_VALUE" }; //$NON-NLS-1$ //$NON-NLS-2$
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.LONG));
-	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveRatherThanWrapperOperation.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveRatherThanWrapperOperation.java
index b13a014..cc1f93a 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveRatherThanWrapperOperation.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveRatherThanWrapperOperation.java
@@ -13,38 +13,65 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.corext.fix;
 
+import java.util.List;
+
 import org.eclipse.core.runtime.CoreException;
 
 import org.eclipse.text.edits.TextEditGroup;
 
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.PrimitiveType;
+import org.eclipse.jdt.core.dom.SimpleType;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
+import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
 import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
 
 import org.eclipse.jdt.internal.corext.dom.ASTNodes;
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
 
-public class PrimitiveRatherThanWrapperOperation extends CompilationUnitRewriteOperation {
-	private final VariableDeclarationStatement node;
-	private final String description;
-	private final PrimitiveType.Code primitiveType;
+import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
 
-	public PrimitiveRatherThanWrapperOperation(final VariableDeclarationStatement node, final String description, final PrimitiveType.Code primitiveType) {
-		this.node= node;
-		this.description= description;
-		this.primitiveType= primitiveType;
+public class PrimitiveRatherThanWrapperOperation extends CompilationUnitRewriteOperation {
+	private final VariableDeclarationStatement visited;
+	private final String primitiveTypeName;
+	private final String wrapperFullyQualifiedName;
+	private final Expression initializer;
+	private final List<MethodInvocation> toStringMethods;
+	private final List<MethodInvocation> compareToMethods;
+	private final List<MethodInvocation> primitiveValueMethods;
+	private final String parsingMethodName;
+
+	public PrimitiveRatherThanWrapperOperation(
+			final VariableDeclarationStatement visited,
+			final String primitiveTypeName,
+			final String wrapperFullyQualifiedName,
+			final Expression initializer,
+			final List<MethodInvocation> toStringMethods,
+			final List<MethodInvocation> compareToMethods,
+			final List<MethodInvocation> primitiveValueMethods,
+			final String parsingMethodName) {
+		this.visited= visited;
+		this.primitiveTypeName= primitiveTypeName;
+		this.wrapperFullyQualifiedName= wrapperFullyQualifiedName;
+		this.initializer= initializer;
+		this.toStringMethods= toStringMethods;
+		this.compareToMethods= compareToMethods;
+		this.primitiveValueMethods= primitiveValueMethods;
+		this.parsingMethodName= parsingMethodName;
 	}
 
 	@Override
 	public void rewriteAST(final CompilationUnitRewrite cuRewrite, final LinkedProposalModelCore linkedModel) throws CoreException {
 		ASTRewrite rewrite= cuRewrite.getASTRewrite();
 		AST ast= cuRewrite.getRoot().getAST();
-		TextEditGroup group= createTextEditGroup(description, cuRewrite);
+		TextEditGroup group= createTextEditGroup(MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, cuRewrite);
 		rewrite.setTargetSourceRangeComputer(new TargetSourceRangeComputer() {
 			@Override
 			public SourceRange computeSourceRange(final ASTNode nodeWithComment) {
@@ -56,8 +83,64 @@
 			}
 		});
 
-		Type newPrimitiveType= ast.newPrimitiveType(primitiveType);
+		MethodInvocation methodInvocation= ASTNodes.as(initializer, MethodInvocation.class);
 
-		ASTNodes.replaceButKeepComment(rewrite, node.getType(), newPrimitiveType, group);
+		if (methodInvocation != null) {
+			if (ASTNodes.usesGivenSignature(methodInvocation, wrapperFullyQualifiedName, "valueOf", primitiveTypeName)) { //$NON-NLS-1$
+				rewrite.replace(methodInvocation, ASTNodes.createMoveTarget(rewrite, (Expression) methodInvocation.arguments().get(0)), group);
+			}
+
+			if (ASTNodes.usesGivenSignature(methodInvocation, wrapperFullyQualifiedName, "valueOf", String.class.getCanonicalName()) //$NON-NLS-1$
+					|| ASTNodes.usesGivenSignature(methodInvocation, wrapperFullyQualifiedName, "valueOf", String.class.getCanonicalName(), int.class.getSimpleName())) { //$NON-NLS-1$
+				rewrite.set(methodInvocation, MethodInvocation.NAME_PROPERTY, ast.newSimpleName(parsingMethodName), group);
+			}
+		}
+
+		ClassInstanceCreation classInstanceCreation= ASTNodes.as(initializer, ClassInstanceCreation.class);
+
+		if (classInstanceCreation != null) {
+			List<Expression> classInstanceCreationArguments= classInstanceCreation.arguments();
+
+			if (classInstanceCreationArguments.size() == 1
+					&& parsingMethodName != null
+					&& !Character.class.getCanonicalName().equals(wrapperFullyQualifiedName)
+					&& ASTNodes.hasType(classInstanceCreation, wrapperFullyQualifiedName)) {
+				Expression arg0= classInstanceCreationArguments.get(0);
+
+				if (ASTNodes.hasType(arg0, String.class.getCanonicalName())) {
+					MethodInvocation newMethodInvocation= ast.newMethodInvocation();
+					newMethodInvocation.setExpression((Expression) rewrite.createCopyTarget(((SimpleType) visited.getType()).getName()));
+					newMethodInvocation.setName(ast.newSimpleName(parsingMethodName));
+					newMethodInvocation.arguments().add(ASTNodes.createMoveTarget(rewrite, ASTNodes.getUnparenthesedExpression(arg0)));
+
+					ASTNodes.replaceButKeepComment(rewrite, initializer, newMethodInvocation, group);
+				}
+			}
+		}
+
+		for (MethodInvocation primitiveValueMethod : primitiveValueMethods) {
+			rewrite.replace(primitiveValueMethod, ASTNodes.createMoveTarget(rewrite, primitiveValueMethod.getExpression()), group);
+		}
+
+		for (MethodInvocation toStringMethod : toStringMethods) {
+			Type wrapperType= (Type) rewrite.createCopyTarget(visited.getType());
+
+			ListRewrite targetListRewrite= rewrite.getListRewrite(toStringMethod, MethodInvocation.ARGUMENTS_PROPERTY);
+			targetListRewrite.insertFirst(ASTNodes.createMoveTarget(rewrite, toStringMethod.getExpression()), group);
+			rewrite.set(toStringMethod, MethodInvocation.EXPRESSION_PROPERTY, wrapperType, group);
+		}
+
+		for (MethodInvocation compareToMethod : compareToMethods) {
+			Type wrapperType= (Type) rewrite.createCopyTarget(visited.getType());
+
+			ListRewrite targetListRewrite= rewrite.getListRewrite(compareToMethod, MethodInvocation.ARGUMENTS_PROPERTY);
+			targetListRewrite.insertFirst(ASTNodes.createMoveTarget(rewrite, compareToMethod.getExpression()), group);
+			rewrite.set(compareToMethod, MethodInvocation.EXPRESSION_PROPERTY, wrapperType, group);
+			rewrite.replace(compareToMethod.getName(), ast.newSimpleName("compare"), group); //$NON-NLS-1$
+		}
+
+		Type newPrimitiveType= ast.newPrimitiveType(PrimitiveType.toCode(primitiveTypeName));
+
+		ASTNodes.replaceButKeepComment(rewrite, visited.getType(), newPrimitiveType, group);
 	}
 }
diff --git a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveShortRatherThanWrapperFinder.java b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveShortRatherThanWrapperFinder.java
index bd223f2..5c17160 100644
--- a/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveShortRatherThanWrapperFinder.java
+++ b/org.eclipse.jdt.core.manipulation/core extension/org/eclipse/jdt/internal/corext/fix/PrimitiveShortRatherThanWrapperFinder.java
@@ -23,15 +23,11 @@
 import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PostfixExpression;
 import org.eclipse.jdt.core.dom.PrefixExpression;
-import org.eclipse.jdt.core.dom.PrimitiveType;
-import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
 
 import org.eclipse.jdt.internal.corext.fix.CompilationUnitRewriteOperationsFixCore.CompilationUnitRewriteOperation;
 
-import org.eclipse.jdt.internal.ui.fix.MultiFixMessages;
-
 public final class PrimitiveShortRatherThanWrapperFinder extends AbstractPrimitiveRatherThanWrapperFinder {
-	public PrimitiveShortRatherThanWrapperFinder(List<CompilationUnitRewriteOperation> ops) {
+	public PrimitiveShortRatherThanWrapperFinder(final List<CompilationUnitRewriteOperation> ops) {
 		fResult= ops;
 	}
 
@@ -104,9 +100,4 @@
 			return false;
 		}
 	}
-
-	@Override
-	public void refactorWrapper(VariableDeclarationStatement node) {
-		fResult.add(new PrimitiveRatherThanWrapperOperation(node, MultiFixMessages.PrimitiveRatherThanWrapperCleanUp_description, PrimitiveType.SHORT));
-	}
 }
diff --git a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
index 655fad1..3998985 100644
--- a/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
+++ b/org.eclipse.jdt.ui.tests/ui/org/eclipse/jdt/ui/tests/quickfix/CleanUpTest.java
@@ -5629,15 +5629,52 @@
 				+ "\n" //
 				+ "    public void replaceWrapper(boolean b) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        /* c1 */ Boolean /* c2 */ alwaysInitializedVar /* c3 */ = /* c4 */ Boolean.TRUE /* c5 */;\n" //
+				+ "        /* c1 */ Boolean /* c2 */ alwaysInitializedVar /* c3 */ = /* c4 */ true /* c5 */;\n" //
 				+ "        if (alwaysInitializedVar && b) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
 				+ "    }\n" //
+				+ "    public void replaceWrapperAndUseParsing(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Boolean alwaysInitializedVar = Boolean.valueOf(\"true\");\n" //
+				+ "        if (alwaysInitializedVar && b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "    public String replaceWrapperAndToStringMethod(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(b);\n" //
+				+ "    }\n" //
+				+ "    public boolean replaceWrapperAndPrimitiveValueMethod() {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.booleanValue();\n" //
+				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(boolean b) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        java.lang.Boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        java.lang.Boolean alwaysInitializedVar = false;\n" //
 				+ "        if (alwaysInitializedVar && b) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5645,7 +5682,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInCast() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        Boolean alwaysInitializedVar = false;\n" //
 				+ "        if ((boolean) alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5653,7 +5690,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInParenthesis() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        Boolean alwaysInitializedVar = false;\n" //
 				+ "        if ((alwaysInitializedVar)) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5733,7 +5770,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInPrefixExpression() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
 				+ "        if (!alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5741,7 +5778,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInIf() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
 				+ "        if (alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5765,19 +5802,19 @@
 				+ "\n" //
 				+ "    public String replaceWrapperInConditionalExpression() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        Boolean alwaysInitializedVar = true;\n" //
 				+ "        return alwaysInitializedVar ? \"foo\" : \"bar\";\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public boolean replaceReturnedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean returnedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean returnedBoolean = true;\n" //
 				+ "        return returnedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public boolean replaceMultiReturnedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean returnedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean returnedBoolean = true;\n" //
 				+ "        if (i > 0) {\n" //
 				+ "            System.out.println(\"Positive\");\n" //
 				+ "            return returnedBoolean;\n" //
@@ -5789,7 +5826,7 @@
 				+ "\n" //
 				+ "    public Boolean replaceReturnedAutoBoxedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean returnedBoolean = Boolean.FALSE;\n" //
+				+ "        Boolean returnedBoolean = false;\n" //
 				+ "        if (i > 0) {\n" //
 				+ "            System.out.println(\"Positive\");\n" //
 				+ "            return returnedBoolean;\n" //
@@ -5801,39 +5838,39 @@
 				+ "\n" //
 				+ "    public void replaceReassignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean reassignedBoolean = Boolean.TRUE;\n" //
-				+ "        reassignedBoolean = Boolean.FALSE;\n" //
+				+ "        Boolean reassignedBoolean = true;\n" //
+				+ "        reassignedBoolean = false;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceMultiReassignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean multiReassignedBoolean = Boolean.TRUE;\n" //
-				+ "        multiReassignedBoolean = Boolean.FALSE;\n" //
-				+ "        multiReassignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean multiReassignedBoolean = true;\n" //
+				+ "        multiReassignedBoolean = false;\n" //
+				+ "        multiReassignedBoolean = true;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceAssignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        Boolean anotherBoolean = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceWrapperAssignedOnBooleanField() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        booleanField = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceWrapperAssignedOnWrapperField() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        wrapperField = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceBitAssignedWrapper(Boolean aBoolean, Boolean anotherBoolean,\n" //
 				+ "            Boolean yetAnotherBoolean) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        aBoolean &= assignedBoolean;\n" //
 				+ "        anotherBoolean |= assignedBoolean;\n" //
 				+ "        yetAnotherBoolean ^= assignedBoolean;\n" //
@@ -5849,15 +5886,52 @@
 				+ "\n" //
 				+ "    public void replaceWrapper(boolean b) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        /* c1 */ boolean /* c2 */ alwaysInitializedVar /* c3 */ = /* c4 */ Boolean.TRUE /* c5 */;\n" //
+				+ "        /* c1 */ boolean /* c2 */ alwaysInitializedVar /* c3 */ = /* c4 */ true /* c5 */;\n" //
 				+ "        if (alwaysInitializedVar && b) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
 				+ "    }\n" //
+				+ "    public void replaceWrapperAndUseParsing(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        boolean alwaysInitializedVar = Boolean.parseBoolean(\"true\");\n" //
+				+ "        if (alwaysInitializedVar && b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "    public String replaceWrapperAndToStringMethod(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Boolean.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(boolean b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Boolean.compare(alwaysInitializedVar, b);\n" //
+				+ "    }\n" //
+				+ "    public boolean replaceWrapperAndPrimitiveValueMethod() {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
+				+ "        if (alwaysInitializedVar) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(boolean b) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        boolean alwaysInitializedVar = false;\n" //
 				+ "        if (alwaysInitializedVar && b) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5865,7 +5939,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInCast() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        boolean alwaysInitializedVar = false;\n" //
 				+ "        if ((boolean) alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5873,7 +5947,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInParenthesis() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.FALSE;\n" //
+				+ "        boolean alwaysInitializedVar = false;\n" //
 				+ "        if ((alwaysInitializedVar)) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5921,7 +5995,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperFromValueOf(boolean b1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean varFromValueOf = Boolean.valueOf(b1);\n" //
+				+ "        boolean varFromValueOf = b1;\n" //
 				+ "        if (varFromValueOf) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5953,7 +6027,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInPrefixExpression() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
 				+ "        if (!alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5961,7 +6035,7 @@
 				+ "\n" //
 				+ "    public void replaceWrapperInIf() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
 				+ "        if (alwaysInitializedVar) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -5985,19 +6059,19 @@
 				+ "\n" //
 				+ "    public String replaceWrapperInConditionalExpression() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean alwaysInitializedVar = Boolean.TRUE;\n" //
+				+ "        boolean alwaysInitializedVar = true;\n" //
 				+ "        return alwaysInitializedVar ? \"foo\" : \"bar\";\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public boolean replaceReturnedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean returnedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean returnedBoolean = true;\n" //
 				+ "        return returnedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public boolean replaceMultiReturnedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean returnedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean returnedBoolean = true;\n" //
 				+ "        if (i > 0) {\n" //
 				+ "            System.out.println(\"Positive\");\n" //
 				+ "            return returnedBoolean;\n" //
@@ -6009,7 +6083,7 @@
 				+ "\n" //
 				+ "    public Boolean replaceReturnedAutoBoxedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean returnedBoolean = Boolean.FALSE;\n" //
+				+ "        boolean returnedBoolean = false;\n" //
 				+ "        if (i > 0) {\n" //
 				+ "            System.out.println(\"Positive\");\n" //
 				+ "            return returnedBoolean;\n" //
@@ -6021,39 +6095,39 @@
 				+ "\n" //
 				+ "    public void replaceReassignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean reassignedBoolean = Boolean.TRUE;\n" //
-				+ "        reassignedBoolean = Boolean.FALSE;\n" //
+				+ "        boolean reassignedBoolean = true;\n" //
+				+ "        reassignedBoolean = false;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceMultiReassignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean multiReassignedBoolean = Boolean.TRUE;\n" //
-				+ "        multiReassignedBoolean = Boolean.FALSE;\n" //
-				+ "        multiReassignedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean multiReassignedBoolean = true;\n" //
+				+ "        multiReassignedBoolean = false;\n" //
+				+ "        multiReassignedBoolean = true;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceAssignedWrapper() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean assignedBoolean = true;\n" //
 				+ "        Boolean anotherBoolean = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceWrapperAssignedOnBooleanField() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean assignedBoolean = true;\n" //
 				+ "        booleanField = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceWrapperAssignedOnWrapperField() {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean assignedBoolean = true;\n" //
 				+ "        wrapperField = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void replaceBitAssignedWrapper(Boolean aBoolean, Boolean anotherBoolean,\n" //
 				+ "            Boolean yetAnotherBoolean) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        boolean assignedBoolean = true;\n" //
 				+ "        aBoolean &= assignedBoolean;\n" //
 				+ "        anotherBoolean |= assignedBoolean;\n" //
 				+ "        yetAnotherBoolean ^= assignedBoolean;\n" //
@@ -6079,48 +6153,53 @@
 				+ "import java.util.Observable;\n" //
 				+ "\n" //
 				+ "public class E {\n" //
-				+ "    public Boolean doNotRefactorFields = Boolean.TRUE;\n" //
+				+ "    public Boolean doNotRefactorFields = true;\n" //
 				+ "    public Object objectField;\n" //
 				+ "\n" //
 				+ "    public Object doNotBreakAutoboxing() {\n" //
+				+ "        Boolean returnedObject = true;\n" //
+				+ "        return returnedObject;\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public Boolean doNotUsePrimitiveWithWrappedInitializer() {\n" //
 				+ "        Boolean returnedObject = Boolean.TRUE;\n" //
 				+ "        return returnedObject;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotReplaceNullWrapper() {\n" //
-				+ "        Boolean reassignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean reassignedBoolean = true;\n" //
 				+ "        reassignedBoolean = null;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotReplaceWrapperPassedAsObject(Map<Boolean, Observable> obsByBoolean) {\n" //
-				+ "        Boolean reassignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean reassignedBoolean = true;\n" //
 				+ "        obsByBoolean.get(reassignedBoolean).notifyObservers();\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotReplaceWrapperAssignedOnObjectField() {\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        objectField = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotReplaceMultiAssignedWrapper() {\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        Boolean anotherBoolean = assignedBoolean;\n" //
 				+ "        Boolean yetAnotherBoolean = assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public Boolean doNotReplaceMultiAutoBoxedWrapper() {\n" //
-				+ "        Boolean assignedBoolean = Boolean.TRUE;\n" //
+				+ "        Boolean assignedBoolean = true;\n" //
 				+ "        Boolean anotherBoolean = assignedBoolean;\n" //
 				+ "        return assignedBoolean;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotBreakAutoboxingOnAssignment() {\n" //
-				+ "        Boolean returnedObject = Boolean.TRUE;\n" //
+				+ "        Boolean returnedObject = true;\n" //
 				+ "        Object anotherObject = returnedObject;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotReplaceRessignedWrapper(Boolean b) {\n" //
-				+ "        Boolean returnedObject = Boolean.TRUE;\n" //
+				+ "        Boolean returnedObject = true;\n" //
 				+ "        try {\n" //
 				+ "            returnedObject = b;\n" //
 				+ "        } catch (Exception e) {\n" //
@@ -6129,13 +6208,13 @@
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public Boolean doNotReplaceAssignedAndReturnedWrapper(Boolean b) {\n" //
-				+ "        Boolean returnedObject = Boolean.FALSE;\n" //
+				+ "        Boolean returnedObject = false;\n" //
 				+ "        returnedObject = b;\n" //
 				+ "        return returnedObject;\n" //
 				+ "    }\n" //
 				+ "\n" //
 				+ "    public void doNotRefactorMultiDeclaration(boolean isValid) {\n" //
-				+ "        Boolean alwaysInitializedVar = Boolean.TRUE, otherVar;\n" //
+				+ "        Boolean alwaysInitializedVar = true, otherVar;\n" //
 				+ "        if (alwaysInitializedVar && isValid) {\n" //
 				+ "            System.out.println(\"True!\");\n" //
 				+ "        }\n" //
@@ -6167,6 +6246,39 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Character alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Character alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(c);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public char replaceWrapperAndPrimitiveValueMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Character alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.charValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(char c) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Character alwaysInitializedVar = Character.MAX_VALUE;\n" //
@@ -6350,6 +6462,39 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        char alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Character.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        char alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Character.compare(alwaysInitializedVar, c);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public char replaceWrapperAndPrimitiveValueMethod(char c) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        char alwaysInitializedVar = Character.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > c) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(char c) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        char alwaysInitializedVar = Character.MAX_VALUE;\n" //
@@ -6384,7 +6529,7 @@
 				+ "\n" //
 				+ "    public int replaceWrapperFromValueOf(char c1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        char varFromValueOf = Character.valueOf(c1);\n" //
+				+ "        char varFromValueOf = c1;\n" //
 				+ "        return +varFromValueOf;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -6609,6 +6754,47 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Byte alwaysInitializedVar = Byte.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(b);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public byte replaceWrapperAndPrimitiveValueMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.byteValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(byte b) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Byte alwaysInitializedVar = Byte.MAX_VALUE;\n" //
@@ -6789,6 +6975,47 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        byte alwaysInitializedVar = Byte.parseByte(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Byte.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Byte.compare(alwaysInitializedVar, b);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public byte replaceWrapperAndPrimitiveValueMethod(byte b) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        byte alwaysInitializedVar = Byte.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > b) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(byte b) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        byte alwaysInitializedVar = Byte.MAX_VALUE;\n" //
@@ -6823,7 +7050,7 @@
 				+ "\n" //
 				+ "    public byte replaceWrapperFromValueOf(byte b1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        byte varFromValueOf = Byte.valueOf(b1);\n" //
+				+ "        byte varFromValueOf = b1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -7045,6 +7272,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Short alwaysInitializedVar = Short.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Short alwaysInitializedVar = new Short(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(s);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public short replaceWrapperAndPrimitiveValueMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.shortValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(short s) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Short alwaysInitializedVar = Short.MIN_VALUE;\n" //
@@ -7231,6 +7507,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        short alwaysInitializedVar = Short.parseShort(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        short alwaysInitializedVar = Short.parseShort(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Short.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Short.compare(alwaysInitializedVar, s);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public short replaceWrapperAndPrimitiveValueMethod(short s) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        short alwaysInitializedVar = Short.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > s) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(short s) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        short alwaysInitializedVar = Short.MIN_VALUE;\n" //
@@ -7268,7 +7593,7 @@
 				+ "\n" //
 				+ "    public short replaceWrapperFromValueOf(short s1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        short varFromValueOf = Short.valueOf(s1);\n" //
+				+ "        short varFromValueOf = s1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -7493,6 +7818,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Integer alwaysInitializedVar = Integer.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsingWithRadix(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Integer alwaysInitializedVar = Integer.valueOf(\"0\", 10);\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Integer alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Integer alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(i);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndPrimitiveValueMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Integer alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.intValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Integer alwaysInitializedVar = Integer.MAX_VALUE;\n" //
@@ -7733,6 +8107,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        int alwaysInitializedVar = Integer.parseInt(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsingWithRadix(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        int alwaysInitializedVar = Integer.parseInt(\"0\", 10);\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        int alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Integer.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        int alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Integer.compare(alwaysInitializedVar, i);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndPrimitiveValueMethod(int i) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        int alwaysInitializedVar = Integer.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > i) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(int i) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        int alwaysInitializedVar = Integer.MAX_VALUE;\n" //
@@ -7818,7 +8241,7 @@
 				+ "\n" //
 				+ "    public int replaceWrapperFromValueOf(int i1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        int varFromValueOf = Integer.valueOf(i1);\n" //
+				+ "        int varFromValueOf = i1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -8049,6 +8472,63 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = Long.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsingWithRadix(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = Long.valueOf(\"0\", 10);\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = new Long(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(l);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public long replaceWrapperAndPrimitiveValueMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.longValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(long l) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Long alwaysInitializedVar = Long.MIN_VALUE;\n" //
@@ -8266,6 +8746,63 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.parseLong(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsingWithRadix(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.parseLong(\"0\", 10);\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.parseLong(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Long.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Long.compare(alwaysInitializedVar, l);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public long replaceWrapperAndPrimitiveValueMethod(long l) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        long alwaysInitializedVar = Long.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > l) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(long l) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        long alwaysInitializedVar = Long.MIN_VALUE;\n" //
@@ -8351,7 +8888,7 @@
 				+ "\n" //
 				+ "    public long replaceWrapperFromValueOf(long l1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        long varFromValueOf = Long.valueOf(l1);\n" //
+				+ "        long varFromValueOf = l1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -8559,6 +9096,47 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Float alwaysInitializedVar = Float.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(f);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public float replaceWrapperAndPrimitiveValueMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.floatValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(float f) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Float alwaysInitializedVar = Float.MIN_VALUE;\n" //
@@ -8759,6 +9337,47 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        float alwaysInitializedVar = Float.parseFloat(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Float.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Float.compare(alwaysInitializedVar, f);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public float replaceWrapperAndPrimitiveValueMethod(float f) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        float alwaysInitializedVar = Float.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > f) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(float f) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        float alwaysInitializedVar = Float.MIN_VALUE;\n" //
@@ -8826,7 +9445,7 @@
 				+ "\n" //
 				+ "    public float replaceWrapperFromValueOf(float f1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        float varFromValueOf = Float.valueOf(f1);\n" //
+				+ "        float varFromValueOf = f1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
@@ -9035,6 +9654,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Double alwaysInitializedVar = Double.valueOf(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Double alwaysInitializedVar = new Double(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.toString();\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.compareTo(d);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public double replaceWrapperAndPrimitiveValueMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        Double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar.doubleValue();\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(double d) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        java.lang.Double alwaysInitializedVar = Double.MAX_VALUE;\n" //
@@ -9246,6 +9914,55 @@
 				+ "        }\n" //
 				+ "    }\n" //
 				+ "\n" //
+				+ "    public void replaceWrapperAndUseParsing(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        double alwaysInitializedVar = Double.parseDouble(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public void replaceWrapperAndConstructor(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        double alwaysInitializedVar = Double.parseDouble(\"0\");\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public String replaceWrapperAndToStringMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Double.toString(alwaysInitializedVar);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public int replaceWrapperAndCompareToMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return Double.compare(alwaysInitializedVar, d);\n" //
+				+ "    }\n" //
+				+ "\n" //
+				+ "    public double replaceWrapperAndPrimitiveValueMethod(double d) {\n" //
+				+ "        // Keep this comment\n" //
+				+ "        double alwaysInitializedVar = Double.MIN_VALUE;\n" //
+				+ "        if (alwaysInitializedVar > d) {\n" //
+				+ "            System.out.println(\"True!\");\n" //
+				+ "        }\n" //
+				+ "\n" //
+				+ "        // Keep this comment too\n" //
+				+ "        return alwaysInitializedVar;\n" //
+				+ "    }\n" //
+				+ "\n" //
 				+ "    public void replaceFullyQualifiedWrapper(double d) {\n" //
 				+ "        // Keep this comment\n" //
 				+ "        double alwaysInitializedVar = Double.MAX_VALUE;\n" //
@@ -9313,7 +10030,7 @@
 				+ "\n" //
 				+ "    public double replaceWrapperFromValueOf(double d1) {\n" //
 				+ "        // Keep this comment\n" //
-				+ "        double varFromValueOf = Double.valueOf(d1);\n" //
+				+ "        double varFromValueOf = d1;\n" //
 				+ "        return varFromValueOf++;\n" //
 				+ "    }\n" //
 				+ "\n" //
diff --git a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
index 31424ae..297041b 100644
--- a/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
+++ b/org.eclipse.jdt.ui/ui/org/eclipse/jdt/internal/ui/preferences/cleanup/CleanUpMessages.properties
@@ -72,7 +72,7 @@
 OptimizationTabPage_CheckboxName_PrimitiveComparison=Primitive comparison
 OptimizationTabPage_CheckboxName_PrimitiveParsing=Primitive parsing
 OptimizationTabPage_CheckboxName_PrimitiveSerialization=&Primitive serialization
-OptimizationTabPage_CheckboxName_PrimitiveRatherThanWrapper=Primitive type rather then wrapper class
+OptimizationTabPage_CheckboxName_PrimitiveRatherThanWrapper=Primitive type rather than wrapper class
 OptimizationTabPage_CheckboxName_PrecompileRegEx=Precompile reused regular e&xpressions
 OptimizationTabPage_CheckboxName_NoStringCreation=Remo&ve redundant string creation
 OptimizationTabPage_CheckboxName_BooleanLiteral=Prefer &boolean literals