refactor: convert to parameterized tests, run spotlessApply

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: queelius

src/test/java/net/sf/jsqlparser/statement/select/SetOperationModifierTest.java

@@ -12,121 +12,82 @@
 import static net.sf.jsqlparser.test.TestUtils.assertSqlCanBeParsedAndDeparsed;
 import static org.junit.jupiter.api.Assertions.*;
 
+import java.util.stream.Stream;
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.statement.Statement;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 
 /**
  * Regression tests for EXCEPT/MINUS ALL/DISTINCT modifier handling.
  * <p>
- * Verifies that the ALL and DISTINCT modifiers are correctly preserved during
- * parse-toString round-trips for all set operation types: UNION, INTERSECT,
- * EXCEPT, and MINUS.
+ * Verifies that the ALL and DISTINCT modifiers are correctly preserved during parse-toString
+ * round-trips for all set operation types: UNION, INTERSECT, EXCEPT, and MINUS.
  *
- * @see <a href="https://github.com/JSQLParser/JSqlParser/issues/2080">#2080</a>
+ * @see <a href="https://github.com/JSQLParser/JSqlParser/issues/2419">#2419</a>
  */
 @Execution(ExecutionMode.CONCURRENT)
 public class SetOperationModifierTest {
 
-    // ── EXCEPT modifier tests ─────────────────────────────────────
-
-    @Test
-    public void testExceptAllRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 EXCEPT ALL SELECT a FROM t2");
-    }
-
-    @Test
-    public void testExceptDistinctRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 EXCEPT DISTINCT SELECT a FROM t2");
-    }
-
-    @Test
-    public void testPlainExceptRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 EXCEPT SELECT a FROM t2");
-    }
-
-    // ── MINUS modifier tests ─────────────────────────────────────
-
-    @Test
-    public void testMinusAllRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 MINUS ALL SELECT a FROM t2");
-    }
-
-    @Test
-    public void testMinusDistinctRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 MINUS DISTINCT SELECT a FROM t2");
-    }
-
-    @Test
-    public void testPlainMinusRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 MINUS SELECT a FROM t2");
-    }
-
-    // ── Cross-check: UNION and INTERSECT still work ──────────────
-
-    @Test
-    public void testUnionAllRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 UNION ALL SELECT a FROM t2");
-    }
-
-    @Test
-    public void testIntersectAllRoundTrip() throws JSQLParserException {
-        assertSqlCanBeParsedAndDeparsed("SELECT a FROM t1 INTERSECT ALL SELECT a FROM t2");
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "SELECT a FROM t1 EXCEPT ALL SELECT a FROM t2",
+            "SELECT a FROM t1 EXCEPT DISTINCT SELECT a FROM t2",
+            "SELECT a FROM t1 EXCEPT SELECT a FROM t2",
+            "SELECT a FROM t1 MINUS ALL SELECT a FROM t2",
+            "SELECT a FROM t1 MINUS DISTINCT SELECT a FROM t2",
+            "SELECT a FROM t1 MINUS SELECT a FROM t2",
+            "SELECT a FROM t1 UNION ALL SELECT a FROM t2",
+            "SELECT a FROM t1 INTERSECT ALL SELECT a FROM t2",
+            "SELECT a FROM t1 UNION ALL SELECT b FROM t2 EXCEPT DISTINCT SELECT c FROM t3"
+    })
+    void testSetOperationModifierRoundTrip(String sql) throws JSQLParserException {
+        assertSqlCanBeParsedAndDeparsed(sql);
     }
 
-    // ── Modifier leak prevention: modifiers must not bleed across operators ──
-
-    @Test
-    public void testModifierDoesNotLeakFromUnionAllToExcept() throws JSQLParserException {
-        String sql = "SELECT a FROM t1 UNION ALL SELECT b FROM t2 EXCEPT SELECT c FROM t3";
+    @ParameterizedTest
+    @MethodSource("provideModifierLeakCases")
+    void testModifierDoesNotLeakBetweenOperators(String sql, String forbidden)
+            throws JSQLParserException {
         Statement stmt = CCJSqlParserUtil.parse(sql);
-        String result = stmt.toString();
-        // EXCEPT must NOT inherit ALL from the preceding UNION ALL
-        assertFalse(result.contains("EXCEPT ALL"),
-                "Modifier should not leak from UNION ALL to a subsequent plain EXCEPT: " + result);
+        String deparsed = stmt.toString();
+        assertFalse(deparsed.contains(forbidden),
+                "Modifier leaked: found '" + forbidden + "' in: " + deparsed);
     }
 
-    @Test
-    public void testModifierDoesNotLeakFromIntersectAllToUnion() throws JSQLParserException {
-        String sql = "SELECT a FROM t1 INTERSECT ALL SELECT b FROM t2 UNION SELECT c FROM t3";
-        Statement stmt = CCJSqlParserUtil.parse(sql);
-        String result = stmt.toString();
-        assertFalse(result.contains("UNION ALL"),
-                "Modifier should not leak from INTERSECT ALL to a subsequent plain UNION: " + result);
+    private static Stream<Arguments> provideModifierLeakCases() {
+        return Stream.of(
+                Arguments.of(
+                        "SELECT a FROM t1 UNION ALL SELECT b FROM t2 EXCEPT SELECT c FROM t3",
+                        "EXCEPT ALL"),
+                Arguments.of(
+                        "SELECT a FROM t1 INTERSECT ALL SELECT b FROM t2 UNION SELECT c FROM t3",
+                        "UNION ALL"));
     }
 
-    @Test
-    public void testMixedModifiersPreserved() throws JSQLParserException {
-        // UNION ALL followed by EXCEPT DISTINCT
-        assertSqlCanBeParsedAndDeparsed(
-                "SELECT a FROM t1 UNION ALL SELECT b FROM t2 EXCEPT DISTINCT SELECT c FROM t3");
+    @ParameterizedTest
+    @MethodSource("provideSetOperationObjectCases")
+    void testSetOperationObjectState(String sql, Class<?> expectedType,
+            boolean expectedAll, boolean expectedDistinct) throws JSQLParserException {
+        SetOperationList setOpList = (SetOperationList) CCJSqlParserUtil.parse(sql);
+        SetOperation op = setOpList.getOperations().get(0);
+        assertInstanceOf(expectedType, op);
+        assertEquals(expectedAll, op.isAll(),
+                "isAll() mismatch for: " + sql);
+        assertEquals(expectedDistinct, op.isDistinct(),
+                "isDistinct() mismatch for: " + sql);
     }
 
-    // ── SetOperation object state verification ──────────────────
-
-    @Test
-    public void testExceptAllSetOperationObject() throws JSQLParserException {
-        String sql = "SELECT a FROM t1 EXCEPT ALL SELECT a FROM t2";
-        Statement stmt = CCJSqlParserUtil.parse(sql);
-        SetOperationList setOpList = (SetOperationList) stmt;
-        SetOperation op = setOpList.getOperation(0);
-
-        assertInstanceOf(ExceptOp.class, op);
-        assertTrue(op.isAll(), "ExceptOp should report isAll() == true");
-        assertFalse(op.isDistinct(), "ExceptOp should report isDistinct() == false");
-    }
-
-    @Test
-    public void testMinusAllSetOperationObject() throws JSQLParserException {
-        String sql = "SELECT a FROM t1 MINUS ALL SELECT a FROM t2";
-        Statement stmt = CCJSqlParserUtil.parse(sql);
-        SetOperationList setOpList = (SetOperationList) stmt;
-        SetOperation op = setOpList.getOperation(0);
-
-        assertInstanceOf(MinusOp.class, op);
-        assertTrue(op.isAll(), "MinusOp should report isAll() == true");
+    private static Stream<Arguments> provideSetOperationObjectCases() {
+        return Stream.of(
+                Arguments.of("SELECT a FROM t1 EXCEPT ALL SELECT a FROM t2",
+                        ExceptOp.class, true, false),
+                Arguments.of("SELECT a FROM t1 MINUS ALL SELECT a FROM t2",
+                        MinusOp.class, true, false));
     }
 }