### Eclipse Workspace Patch 1.0
#P org.eclipse.jdt.core.tests.model
Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java,v
retrieving revision 1.27
diff -u -r1.27 ASTRewritingStatementsTest.java
--- src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java	3 Dec 2008 14:36:39 -0000	1.27
+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingStatementsTest.java	4 Feb 2009 11:49:48 -0000
@@ -19,6 +19,7 @@
 import org.eclipse.jdt.core.dom.*;
 import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
 import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
+import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
 
 public class ASTRewritingStatementsTest extends ASTRewritingTest {
 
@@ -2973,6 +2974,650 @@
 		assertEqualString(preview, buf.toString());
 
 	}
+	
+	public void testSwitchStatement2() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        }\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("            break;\n");
+			buf.append("        case 2:\n");
+			buf.append("            i= 2;\n");
+			buf.append("            break;\n");
+			buf.append("        default:\n");
+			buf.append("            i= 3;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 2", blockStatements.size() == 2);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+	
+				ASTNode expression= switchStatement.getExpression();
+				SimpleName newExpression= ast.newSimpleName("x");
+				rewrite.replace(expression, newExpression, null);
+	
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 0", statements.size() == 0);
+	
+				SwitchCase caseStatement1= ast.newSwitchCase();
+				caseStatement1.setExpression(ast.newNumberLiteral("1"));
+	
+				Statement statement1= ast.newReturnStatement();
+	
+				SwitchCase caseStatement2= ast.newSwitchCase(); // default
+				caseStatement2.setExpression(null);
+	
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.insertLast(caseStatement1, null);
+				listRewrite.insertLast(statement1, null);
+				listRewrite.insertLast(caseStatement2, null);
+			}
+	
+			{ // insert, remove, replace statements, change case statements
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(1);
+	
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 8", statements.size() == 8);
+	
+				// remove statements
+	
+				rewrite.remove((ASTNode) statements.get(0), null);
+				rewrite.remove((ASTNode) statements.get(1), null);
+				rewrite.remove((ASTNode) statements.get(2), null);
+	
+				// change case statement
+				SwitchCase caseStatement= (SwitchCase) statements.get(3);
+				Expression newCaseExpression= ast.newNumberLiteral("10");
+				rewrite.replace(caseStatement.getExpression(), newCaseExpression, null);
+	
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+	
+				{
+					// insert case statement
+					SwitchCase caseStatement2= ast.newSwitchCase();
+					caseStatement2.setExpression(ast.newNumberLiteral("11"));
+					listRewrite.insertFirst(caseStatement2, null);
+	
+					// insert statement
+					Statement statement1= ast.newReturnStatement();
+					listRewrite.insertAfter(statement1, caseStatement2, null);
+				}
+	
+				{
+					// insert case statement
+					SwitchCase caseStatement2= ast.newSwitchCase();
+					caseStatement2.setExpression(ast.newNumberLiteral("12"));
+					listRewrite.insertLast(caseStatement2, null);
+	
+					// insert statement
+					Statement statement1= ast.newReturnStatement();
+					listRewrite.insertAfter(statement1, caseStatement2, null);
+				}
+	
+	
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (x) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            return;\n");
+			buf.append("        default:\n");
+			buf.append("        }\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 11:\n");
+			buf.append("            return;\n");
+			buf.append("        case 10:\n");
+			buf.append("            i= 2;\n");
+			buf.append("            break;\n");
+			buf.append("        default:\n");
+			buf.append("            i= 3;\n");
+			buf.append("        case 12:\n");
+			buf.append("            return;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	public void testSwitchStatement3() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 2:\n");
+			buf.append("            i= 2;\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 2", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 0", statements.size() == 5);
+				
+				SwitchCase caseStatement = (SwitchCase)statements.get(2);
+	
+				BreakStatement breakStatement= ast.newBreakStatement();
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.insertBefore(breakStatement, caseStatement, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("            break;\n");
+			buf.append("        case 2:\n");
+			buf.append("            i= 2;\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Insert a statement before an unchanged statement (and preceded by an unchanged statement)
+	 */
+	public void testSwitchStatement5() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				SwitchCase caseStatement = (SwitchCase)statements.get(2); // case 2:
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.insertBefore(ast.newBreakStatement(), caseStatement, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("            break;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Insert a statement after an unchanged statement (and preceded by an unchanged statement)
+	 */
+	public void testSwitchStatement6() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.insertAfter(ast.newBreakStatement(), assignment, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("            break;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Replace a statement preceded by an unchanged statement)
+	 */
+	public void testSwitchStatement7() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 3:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
+				
+				SwitchCase switchCase = ast.newSwitchCase();
+				switchCase.setExpression(ast.newNumberLiteral("2"));
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.replace(assignment, switchCase, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("        case 2:\n");
+			buf.append("        case 3:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Remove a statement preceded by an unchanged statement)
+	 */
+	public void testSwitchStatement8() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.remove(assignment, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Remove a statement followed by an inserted statement)
+	 */
+	public void testSwitchStatement9() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 3:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+			
+			AST ast= astRoot.getAST();
+	
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;
+				
+				SwitchCase switchCase = ast.newSwitchCase();
+				switchCase.setExpression(ast.newNumberLiteral("2"));
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.remove(assignment, null);
+				listRewrite.insertAfter(switchCase, assignment, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("        case 2:\n");
+			buf.append("        case 3:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
+	
+	/*
+	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=246627
+	 * Remove a statement preceded by an inserted statement)
+	 */
+	public void testSwitchStatement10() throws Exception {
+		String previousValue = null;
+		try {
+			previousValue = this.project1.getOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, false);
+			
+			this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.FALSE);
+			
+			IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
+			StringBuffer buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            i= 1;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			ICompilationUnit cu= pack1.createCompilationUnit("E.java", buf.toString(), false, null);
+	
+			CompilationUnit astRoot= createAST(cu);
+			ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());
+			
+			AST ast= astRoot.getAST();
+			
+			assertTrue("Parse errors", (astRoot.getFlags() & ASTNode.MALFORMED) == 0);
+			TypeDeclaration type= findTypeDeclaration(astRoot, "E");
+			MethodDeclaration methodDecl= findMethodDeclaration(type, "foo");
+			Block block= methodDecl.getBody();
+			List blockStatements= block.statements();
+			assertTrue("Number of statements not 1", blockStatements.size() == 1);
+			{ // insert statements, replace expression
+				SwitchStatement switchStatement= (SwitchStatement) blockStatements.get(0);
+				
+				List statements= switchStatement.statements();
+				assertTrue("Number of statements not 4", statements.size() == 4);
+				
+				ExpressionStatement assignment = (ExpressionStatement)statements.get(1); // i= 1;:
+				
+				ListRewrite listRewrite= rewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY);
+				listRewrite.insertBefore(ast.newBreakStatement(), assignment, null);
+				listRewrite.remove(assignment, null);
+			}
+	
+			String preview= evaluateRewrite(cu, rewrite);
+	
+			buf= new StringBuffer();
+			buf.append("package test1;\n");
+			buf.append("public class E {\n");
+			buf.append("    public void foo(int i) {\n");
+			buf.append("        switch (i) {\n");
+			buf.append("        case 1:\n");
+			buf.append("            break;\n");
+			buf.append("        case 2:\n");
+			buf.append("            break;\n");
+			buf.append("        }\n");
+			buf.append("    }\n");
+			buf.append("}\n");
+			assertEqualString(preview, buf.toString());
+		} finally {
+			if (previousValue != null) {
+				this.project1.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, previousValue);
+			}
+		}
+	}
 
 	public void testSynchronizedStatement() throws Exception {
 		IPackageFragment pack1= this.sourceFolder.createPackageFragment("test1", false, null);
Index: src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java,v
retrieving revision 1.22
diff -u -r1.22 ASTRewritingTest.java
--- src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	27 Jun 2008 16:02:41 -0000	1.22
+++ src/org/eclipse/jdt/core/tests/rewrite/describing/ASTRewritingTest.java	4 Feb 2009 11:49:48 -0000
@@ -71,6 +71,8 @@
 		IJavaProject proj= createJavaProject("P", new String[] {"src"}, "bin");
 		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, JavaCore.SPACE);
 		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_TAB_SIZE, "4");
+		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES, DefaultCodeFormatterConstants.TRUE);
+		proj.setOption(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH, DefaultCodeFormatterConstants.TRUE);
 		proj.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
 		proj.setOption(JavaCore.COMPILER_PB_ASSERT_IDENTIFIER, JavaCore.ERROR);
 		proj.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
#P org.eclipse.jdt.core
Index: dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java
===================================================================
RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java,v
retrieving revision 1.59
diff -u -r1.59 ASTRewriteAnalyzer.java
--- dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	5 Nov 2008 14:30:17 -0000	1.59
+++ dom/org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.java	4 Feb 2009 11:49:51 -0000
@@ -25,6 +25,7 @@
 import org.eclipse.jdt.core.dom.*;
 import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer;
 import org.eclipse.jdt.core.dom.rewrite.TargetSourceRangeComputer.SourceRange;
+import org.eclipse.jdt.core.formatter.DefaultCodeFormatterConstants;
 import org.eclipse.jdt.core.formatter.IndentManipulation;
 import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
 import org.eclipse.jdt.internal.core.dom.rewrite.ASTRewriteFormatter.BlockContext;
@@ -79,6 +80,8 @@
 	private final LineCommentEndOffsets lineCommentEndOffsets;
 	
 	private int beforeRequiredSpaceIndex = -1;
+	
+	Map options;
 
 	/**
 	 * Constructor for ASTRewriteAnalyzer.
@@ -105,6 +108,8 @@
 
 		this.extendedSourceRangeComputer = extendedSourceRangeComputer;
 		this.lineCommentEndOffsets= new LineCommentEndOffsets(comments);
+		
+		this.options = options;
 	}
 
 	final TokenScanner getScanner() {
@@ -491,6 +496,7 @@
 			}
 
 			int prevEnd= currPos;
+			int prevMark= RewriteEvent.UNCHANGED;
 
 			final int NONE= 0, NEW= 1, EXISTING= 2;
 			int separatorState= NEW;
@@ -509,6 +515,10 @@
 						separatorState= NEW;
 					}
 					if (separatorState == NEW || insertAfterSeparator(node)) {
+						if (separatorState == EXISTING) {
+							updateIndent(prevMark, currPos, i, editGroup);
+						}
+						
 						doTextInsert(currPos, node, getNodeIndent(i), true, editGroup); // insert node
 
 						separatorState= NEW;
@@ -534,6 +544,10 @@
 						currPos= currEnd;
 						prevEnd= currEnd;
 					} else {
+						if (i < lastNonDelete) {
+							updateIndent(prevMark, currPos, i, editGroup);
+						}
+						
 						// remove element and next separator
 						int end= getStartOfNextNode(nextIndex, currEnd); // start of next
 						doTextRemoveAndVisit(currPos, currEnd - currPos, node, getEditGroup(currEvent)); // remove node
@@ -549,6 +563,9 @@
 
 						TextEditGroup editGroup= getEditGroup(currEvent);
 						ASTNode changed= (ASTNode) currEvent.getNewValue();
+						
+						updateIndent(prevMark, currPos, i, editGroup);
+						
 						doTextRemoveAndVisit(currPos, currEnd - currPos, node, editGroup);
 						doTextInsert(currPos, changed, getNodeIndent(i), true, editGroup);
 
@@ -574,11 +591,15 @@
 						separatorState= EXISTING;
 					}
 				}
-
+				
+				prevMark = currMark;
 			}
 			return currPos;
 		}
-
+		
+		protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
+			// Do nothing.
+		}
 	}
 
 	private int rewriteRequiredNode(ASTNode parent, StructuralPropertyDescriptor property) {
@@ -794,6 +815,10 @@
 		}
 
 		protected String getSeparatorString(int nodeIndex) {
+			return getSeparatorString(nodeIndex, nodeIndex + 1);
+		}
+		
+		protected String getSeparatorString(int nodeIndex, int nextNodeIndex) {
 			int newLines= this.separatorLines == -1 ? getNewLines(nodeIndex) : this.separatorLines;
 
 			String lineDelim= getLineDelimiter();
@@ -801,7 +826,7 @@
 			for (int i= 0; i < newLines; i++) {
 				buf.append(lineDelim);
 			}
-			buf.append(createIndentString(getNodeIndent(nodeIndex + 1)));
+			buf.append(createIndentString(getNodeIndent(nextNodeIndex)));
 			return buf.toString();
 		}
 
@@ -2651,22 +2676,71 @@
 	}
 
 	class SwitchListRewriter extends ParagraphListRewriter {
+		
+		private boolean indentSwitchStatementsCompareToCases;
 
 		public SwitchListRewriter(int initialIndent) {
 			super(initialIndent, 0);
+			this.indentSwitchStatementsCompareToCases = 
+				DefaultCodeFormatterConstants.TRUE.equals(ASTRewriteAnalyzer.this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_CASES));
 		}
 
 		protected int getNodeIndent(int nodeIndex) {
 			int indent= getInitialIndent();
-			ASTNode node= (ASTNode) this.list[nodeIndex].getOriginalValue();
-			if (node == null) {
-				node= (ASTNode) this.list[nodeIndex].getNewValue();
-			}
-			if (node.getNodeType() != ASTNode.SWITCH_CASE) {
-				indent++;
+			
+			if (this.indentSwitchStatementsCompareToCases) {
+				RewriteEvent event = this.list[nodeIndex];
+				int changeKind = event.getChangeKind();
+				
+				ASTNode node;
+				if (changeKind == RewriteEvent.INSERTED || changeKind == RewriteEvent.REPLACED) {
+					node= (ASTNode)event.getNewValue();
+				} else {
+					node= (ASTNode)event.getOriginalValue();
+				}
+				
+				if (node.getNodeType() != ASTNode.SWITCH_CASE) {
+					indent++;
+				}
 			}
 			return indent;
 		}
+		
+		protected String getSeparatorString(int nodeIndex) {
+			int total = this.list.length;
+			
+			int nextNodeIndex = nodeIndex + 1;
+			while (nextNodeIndex < total && this.list[nextNodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
+				nextNodeIndex++;
+			}
+			if (nextNodeIndex == total) {
+				return super.getSeparatorString(nodeIndex);
+			}
+			return getSeparatorString(nodeIndex, nextNodeIndex);
+		}
+		
+		protected void updateIndent(int prevMark, int originalOffset, int nodeIndex, TextEditGroup editGroup) {
+			if (prevMark != RewriteEvent.UNCHANGED && prevMark != RewriteEvent.REPLACED) return;
+			
+			int total = this.list.length;
+			while (nodeIndex < total && this.list[nodeIndex].getChangeKind() == RewriteEvent.REMOVED) {
+				nodeIndex++;
+			}
+			
+			int originalIndent = getIndent(originalOffset);
+			int newIndent = getNodeIndent(nodeIndex);
+			
+			if (originalIndent != newIndent) {
+				
+				int line= getLineInformation().getLineOfOffset(originalOffset);
+				if (line >= 0) {
+					int lineStart= getLineInformation().getLineOffset(line);
+					
+					doTextRemove(lineStart, originalOffset - lineStart, editGroup); // remove previous indentation
+					doTextInsert(lineStart, createIndentString(newIndent), editGroup); // add new indentation
+				}
+			}
+		}
 	}
 
 	/* (non-Javadoc)
@@ -2683,8 +2757,11 @@
 		if (getChangeKind(node, property) != RewriteEvent.UNCHANGED) {
 			try {
 				pos= getScanner().getTokenEndOffset(ITerminalSymbols.TokenNameLBRACE, pos);
-				int insertIndent= getIndent(node.getStartPosition()) + 1;
-
+				int insertIndent= getIndent(node.getStartPosition());
+				if (DefaultCodeFormatterConstants.TRUE.equals(this.options.get(DefaultCodeFormatterConstants.FORMATTER_INDENT_SWITCHSTATEMENTS_COMPARE_TO_SWITCH))) {
+					insertIndent++;
+				}
+				
 				ParagraphListRewriter listRewriter= new SwitchListRewriter(insertIndent);
 				StringBuffer leadString= new StringBuffer();
 				leadString.append(getLineDelimiter());