spotless

Author: luigidellaquila

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/parser/StatementParserTests.java

@@ -328,7 +328,7 @@ public void testStatsWithoutAggsOrGroup() {
     }
 
     public void testAggsWithGroupKeyAsAgg() {
-        var queries = new String[]{"""
+        var queries = new String[] { """
             row a = 1, b = 2
             | stats a by a
             """, """
@@ -341,7 +341,7 @@ public void testAggsWithGroupKeyAsAgg() {
             """, """
             row a = 1, b = 2
             | stats x = a by a
-            """};
+            """ };
 
         for (String query : queries) {
             expectVerificationError(query, "grouping key [a] already specified in the STATS BY clause");
@@ -891,16 +891,16 @@ public void testInvalidQuotingAsLookupIndexPattern() {
     }
 
     public void testIdentifierAsFieldName() {
-        String[] operators = new String[]{"==", "!=", ">", "<", ">=", "<="};
-        Class<?>[] expectedOperators = new Class<?>[]{
+        String[] operators = new String[] { "==", "!=", ">", "<", ">=", "<=" };
+        Class<?>[] expectedOperators = new Class<?>[] {
             Equals.class,
             Not.class,
             GreaterThan.class,
             LessThan.class,
             GreaterThanOrEqual.class,
-            LessThanOrEqual.class};
-        String[] identifiers = new String[]{"abc", "`abc`", "ab_c", "a.b.c", "@a", "a.@b", "`[email protected]`"};
-        String[] expectedIdentifiers = new String[]{"abc", "abc", "ab_c", "a.b.c", "@a", "a.@b", "[email protected]"};
+            LessThanOrEqual.class };
+        String[] identifiers = new String[] { "abc", "`abc`", "ab_c", "a.b.c", "@a", "a.@b", "`[email protected]`" };
+        String[] expectedIdentifiers = new String[] { "abc", "abc", "ab_c", "a.b.c", "@a", "a.@b", "[email protected]" };
         LogicalPlan where;
         for (int i = 0; i < operators.length; i++) {
             for (int j = 0; j < identifiers.length; j++) {
@@ -1033,7 +1033,7 @@ public void testSingleLineComments() {
     }
 
     public void testNewLines() {
-        String[] delims = new String[]{"", "\r", "\n", "\r\n"};
+        String[] delims = new String[] { "", "\r", "\n", "\r\n" };
         Function<String, String> queryFun = d -> d + "from " + d + " foo " + d + "| eval " + d + " x = concat(bar, \"baz\")" + d;
         LogicalPlan reference = statement(queryFun.apply(delims[0]));
         for (int i = 1; i < delims.length; i++) {
@@ -2941,13 +2941,13 @@ public void testNamedFunctionArgumentNotInMap() {
 
     public void testNamedFunctionArgumentNotConstant() {
         Map<String, String[]> commands = Map.ofEntries(
-            Map.entry("eval x = {}", new String[]{"31", "35"}),
-            Map.entry("where {}", new String[]{"28", "32"}),
-            Map.entry("stats {}", new String[]{"28", "32"}),
-            Map.entry("stats agg() by {}", new String[]{"37", "41"}),
-            Map.entry("sort {}", new String[]{"27", "31"}),
-            Map.entry("dissect {} \"%{bar}\"", new String[]{"30", "34"}),
-            Map.entry("grok {} \"%{WORD:foo}\"", new String[]{"27", "31"})
+            Map.entry("eval x = {}", new String[] { "31", "35" }),
+            Map.entry("where {}", new String[] { "28", "32" }),
+            Map.entry("stats {}", new String[] { "28", "32" }),
+            Map.entry("stats agg() by {}", new String[] { "37", "41" }),
+            Map.entry("sort {}", new String[] { "27", "31" }),
+            Map.entry("dissect {} \"%{bar}\"", new String[] { "30", "34" }),
+            Map.entry("grok {} \"%{WORD:foo}\"", new String[] { "27", "31" })
         );
 
         for (Map.Entry<String, String[]> command : commands.entrySet()) {
@@ -3176,7 +3176,7 @@ public void testValidJoinPattern() {
     }
 
     public void testInvalidFromPatterns() {
-        var sourceCommands = Build.current().isSnapshot() ? new String[]{"FROM", "TS"} : new String[]{"FROM"};
+        var sourceCommands = Build.current().isSnapshot() ? new String[] { "FROM", "TS" } : new String[] { "FROM" };
         var indexIsBlank = "Blank index specified in index pattern";
         var remoteIsEmpty = "remote part is empty";
         var invalidDoubleColonUsage = "invalid usage of :: separator";
@@ -3226,7 +3226,7 @@ public void testInvalidPatternsWithIntermittentQuotes() {
             var randomIndex = randomIndexPattern();
             // Select an invalid char to sneak in.
             // Note: some chars like '|' and '"' are excluded to generate a proper invalid name.
-            Character[] invalidChars = {' ', '/', '<', '>', '?'};
+            Character[] invalidChars = { ' ', '/', '<', '>', '?' };
             var randomInvalidChar = randomFrom(invalidChars);
 
             // Construct the new invalid index pattern.
@@ -3664,7 +3664,7 @@ public void testInvalidFork() {
     }
 
     public void testFieldNamesAsCommands() throws Exception {
-        String[] keywords = new String[]{
+        String[] keywords = new String[] {
             "dissect",
             "drop",
             "enrich",
@@ -3677,7 +3677,7 @@ public void testFieldNamesAsCommands() throws Exception {
             "mv_expand",
             "rename",
             "sort",
-            "stats"};
+            "stats" };
         for (String keyword : keywords) {
             var plan = statement("FROM test | STATS avg(" + keyword + ")");
             var aggregate = as(plan, Aggregate.class);
@@ -4724,7 +4724,7 @@ public void testUnclosedParenthesis() {
             "ROW x = 1 | DROP x )",
             "ROW a = [1, 2] | RENAME a =b)",
             "ROW a = [1, 2] | MV_EXPAND a)",
-            "from test | enrich a on b)"};
+            "from test | enrich a on b)" };
         for (String q : queries) {
             expectError(q, "Invalid query");
         }
@@ -4746,7 +4746,8 @@ public void testBracketsInIndexNames() {
             "((((()))))",
             "(((abc)))",
             "*()*",
-            "*test()*");
+            "*test()*"
+        );
 
         for (String pattern : patterns) {
             expectErrorForBracketsWithoutQuotes(pattern);
@@ -4760,30 +4761,15 @@ public void testBracketsInIndexNames() {
     }
 
     private void expectErrorForBracketsWithoutQuotes(String pattern) {
-        expectThrows(
-            ParsingException.class,
-            () -> processingCommand("from " + pattern)
-        );
+        expectThrows(ParsingException.class, () -> processingCommand("from " + pattern));
 
-        expectThrows(
-            ParsingException.class,
-            () -> processingCommand("from *:" + pattern)
-        );
+        expectThrows(ParsingException.class, () -> processingCommand("from *:" + pattern));
 
-        expectThrows(
-            ParsingException.class,
-            () -> processingCommand("from remote1:" + pattern + ",remote2:" + pattern)
-        );
+        expectThrows(ParsingException.class, () -> processingCommand("from remote1:" + pattern + ",remote2:" + pattern));
 
-        expectThrows(
-            ParsingException.class,
-            () -> processingCommand("from test | lookup join " + pattern + " on bar")
-        );
+        expectThrows(ParsingException.class, () -> processingCommand("from test | lookup join " + pattern + " on bar"));
 
-        expectThrows(
-            ParsingException.class,
-            () -> processingCommand("from test | enrich " + pattern)
-        );
+        expectThrows(ParsingException.class, () -> processingCommand("from test | enrich " + pattern));
     }
 
     private void expectSuccessForBracketsWithinQuotes(String indexName) {
@@ -4805,10 +4791,7 @@ private void expectSuccessForBracketsWithinQuotes(String indexName) {
         as(enrich.child(), UnresolvedRelation.class);
 
         if (indexName.contains("*")) {
-            expectThrows(
-                ParsingException.class,
-                () -> processingCommand("from test | lookup join \"" + indexName + "\" on bar")
-            );
+            expectThrows(ParsingException.class, () -> processingCommand("from test | lookup join \"" + indexName + "\" on bar"));
         } else {
             plan = statement("from test | lookup join \"" + indexName + "\" on bar");
             LookupJoin lookup = as(plan, LookupJoin.class);