feat: Add API method CtAbstractSwitch.addCaseAt (INRIA#4015)

Author: algomaster99

src/main/java/spoon/reflect/code/CtAbstractSwitch.java

@@ -60,6 +60,17 @@ public interface CtAbstractSwitch<S> extends CtElement {
 	@PropertySetter(role = CASE)
 	<T extends CtAbstractSwitch<S>> T addCase(CtCase<? super S> c);
 
+	/**
+	 * Adds a case at the specified position.
+	 *
+	 * @param <T>      type of the switch - {@link CtSwitch} or {@link CtSwitchExpression}
+	 * @param position index at which the case needs to be inserted
+	 * @param c        case which has to be inserted in the switch block
+	 * @return         switch block in which the case is inserted
+	 */
+	@PropertySetter(role = CASE)
+	<T extends CtAbstractSwitch<S>> T addCaseAt(int position, CtCase<? super S> c);
+
 	/**
 	 * Removes a case;
 	 */

src/main/java/spoon/support/reflect/code/CtSwitchExpressionImpl.java

@@ -72,6 +72,12 @@ public <T extends CtAbstractSwitch<S>> T setSelector(CtExpression<S> selector) {
 
 	@Override
 	public <T extends CtAbstractSwitch<S>> T addCase(CtCase<? super S> c) {
+		addCaseAt(cases.size(), c);
+		return (T) this;
+	}
+
+	@Override
+	public <T extends CtAbstractSwitch<S>> T addCaseAt(int position, CtCase<? super S> c) {
 		if (c == null) {
 			return (T) this;
 		}
@@ -80,7 +86,7 @@ public <T extends CtAbstractSwitch<S>> T addCase(CtCase<? super S> c) {
 		}
 		c.setParent(this);
 		getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CASE, this.cases, c);
-		cases.add(c);
+		cases.add(position, c);
 		return (T) this;
 	}
 

src/main/java/spoon/support/reflect/code/CtSwitchImpl.java

@@ -72,6 +72,12 @@ public <T extends CtAbstractSwitch<S>> T setSelector(CtExpression<S> selector) {
 
 	@Override
 	public <T extends CtAbstractSwitch<S>> T addCase(CtCase<? super S> c) {
+		addCaseAt(cases.size(), c);
+		return (T) this;
+	}
+
+	@Override
+	public <T extends CtAbstractSwitch<S>> T addCaseAt(int position, CtCase<? super S> c) {
 		if (c == null) {
 			return (T) this;
 		}
@@ -80,7 +86,7 @@ public <T extends CtAbstractSwitch<S>> T addCase(CtCase<? super S> c) {
 		}
 		c.setParent(this);
 		getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CASE, this.cases, c);
-		cases.add(c);
+		cases.add(position, c);
 		return (T) this;
 	}
 

src/test/java/spoon/test/model/SwitchCaseTest.java

@@ -13,6 +13,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static spoon.testing.utils.ModelUtils.build;
 import static spoon.testing.utils.ModelUtils.createFactory;
@@ -31,6 +32,7 @@
 import spoon.reflect.code.CaseKind;
 import spoon.reflect.code.CtBreak;
 import spoon.reflect.code.CtCase;
+import spoon.reflect.code.CtExpression;
 import spoon.reflect.code.CtIf;
 import spoon.reflect.code.CtLiteral;
 import spoon.reflect.code.CtLocalVariable;
@@ -249,4 +251,118 @@ public void testJava14yield() {
 		}
 	}
 
+	@Nested
+	class InsertCaseInSwitch {
+		@DisplayName("cases should be inserted at the correct position")
+		@Test
+		public void test_addCaseAt_addsCaseAtSpecifiedPositionInSwitch() {
+			// contract: case should be added at the specified position in `CtSwitch`
+			Factory factory = new Launcher().getFactory();
+
+			CtSwitch<Integer> switchBlock = factory.createSwitch();
+			CtExpression<Integer> switchSelector = factory.createCodeSnippetExpression("x");
+			switchBlock.setSelector(switchSelector);
+
+			CtBreak ctBreak = factory.createBreak();
+
+			CtCase<Integer> first = factory.createCase();
+			CtExpression<Integer> firstExpression = factory.createCodeSnippetExpression("1");
+			first.addCaseExpression(firstExpression);
+			first.setCaseKind(CaseKind.COLON);
+			first.addStatement(ctBreak);
+
+			CtCase<Integer> second = factory.createCase();
+			CtExpression<Integer> secondExpression = factory.createCodeSnippetExpression("2");
+			second.addCaseExpression(secondExpression);
+			second.setCaseKind(CaseKind.COLON);
+			second.addStatement(ctBreak);
+
+			CtCase<Integer> third = factory.createCase();
+			third.setCaseKind(CaseKind.COLON);
+			third.addStatement(ctBreak);
+
+			switchBlock.addCaseAt(0, third);
+			switchBlock.addCaseAt(0,first);
+			switchBlock.addCaseAt(1, second);
+
+			assertEquals(Arrays.asList(first, second, third), switchBlock.getCases());
+		}
+
+		@DisplayName("should throw IndexOutOfBounds exception")
+		@Test
+		public void test_addCaseAt_throwsIndexOutOfBoundsException_whenPositionIsOutOfBounds() {
+			// contract: `addCaseAt` should throw an out of bounds exception when the the specified position is out of
+			// bounds of the case collection
+			Factory factory = new Launcher().getFactory();
+
+			CtSwitch<Integer> switchBlock = factory.createSwitch();
+			CtExpression<Integer> switchSelector = factory.createCodeSnippetExpression("x");
+			switchBlock.setSelector(switchSelector);
+
+			CtCase<Integer> onlyCase = factory.createCase();
+			CtBreak caseStatement = factory.createBreak();
+			onlyCase.setCaseKind(CaseKind.COLON);
+			onlyCase.addStatement(caseStatement);
+
+			assertThrows(IndexOutOfBoundsException.class, () -> switchBlock.addCaseAt(5, onlyCase));
+		}
+	}
+
+	@Nested
+	class InsertCaseInSwitchExpression {
+		@DisplayName("cases should be inserted at the correct position")
+		@Test
+		public void test_addCaseAt_addsCaseAtSpecifiedPositionInSwitchExpression() {
+			// contract: case should be added at the specified position in `CtSwitchExpression`
+			Factory factory = new Launcher().getFactory();
+
+			CtSwitchExpression<Integer, Integer> switchExpression = factory.createSwitchExpression();
+			CtExpression<Integer> switchSelector = factory.createCodeSnippetExpression("x");
+			switchExpression.setSelector(switchSelector);
+
+			CtCase<Integer> first = factory.createCase();
+			CtExpression<Integer> firstExpression = factory.createCodeSnippetExpression("1");
+			CtStatement firstStatement = factory.createCodeSnippetStatement("1");
+			first.addCaseExpression(firstExpression);
+			first.setCaseKind(CaseKind.ARROW);
+			first.addStatement(firstStatement);
+
+			CtCase<Integer> second = factory.createCase();
+			CtExpression<Integer> secondExpression = factory.createCodeSnippetExpression("2");
+			CtStatement secondStatement = factory.createCodeSnippetStatement("2");
+			second.addCaseExpression(secondExpression);
+			second.setCaseKind(CaseKind.ARROW);
+			second.addStatement(secondStatement);
+
+			CtCase<Integer> third = factory.createCase();
+			CtStatement thirdStatement = factory.createCodeSnippetStatement("3");
+			third.setCaseKind(CaseKind.ARROW);
+			third.addStatement(thirdStatement);
+
+			switchExpression.addCaseAt(0, third);
+			switchExpression.addCaseAt(0,first);
+			switchExpression.addCaseAt(1, second);
+
+			assertEquals(Arrays.asList(first, second, third), switchExpression.getCases());
+		}
+
+		@DisplayName("should throw IndexOutOfBounds exception")
+		@Test
+		public void test_addCaseAt_throwsIndexOutOfBoundsException_whenPositionIsOutOfBounds() {
+			// contract: `addCaseAt` should throw an out of bounds exception when the the specified position is out of
+			// bounds of the case collection
+			Factory factory = new Launcher().getFactory();
+
+			CtSwitchExpression<Integer, Integer> switchExpression = factory.createSwitchExpression();
+			CtExpression<Integer> switchSelector = factory.createCodeSnippetExpression("x");
+			switchExpression.setSelector(switchSelector);
+
+			CtCase<Integer> onlyCase = factory.createCase();
+			CtStatement caseStatement = factory.createCodeSnippetStatement("5");
+			onlyCase.setCaseKind(CaseKind.ARROW);
+			onlyCase.addStatement(caseStatement);
+
+			assertThrows(IndexOutOfBoundsException.class, () -> switchExpression.addCaseAt(3, onlyCase));
+		}
+	}
 }