build: try to work around the Maven/JDK8 issue on GitHub

manticore-projects · manticore-projects · commit 4bdabed464e7 · 2023-05-17T19:17:32.000+07:00
diff --git a/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java b/src/main/java/net/sf/jsqlparser/parser/CCJSqlParserUtil.java
@@ -296,17 +296,18 @@ public static Expression parseCondExpression(String conditionalExpressionStr,
     public static Statement parseStatement(CCJSqlParser parser, ExecutorService executorService)
             throws JSQLParserException {
         Statement statement = null;
+        Future<Statement> future = executorService.submit(new Callable<Statement>() {
+            @Override
+            public Statement call() throws Exception {
+                return parser.Statement();
+            }
+        });
         try {
-            Future<Statement> future = executorService.submit(new Callable<Statement>() {
-                @Override
-                public Statement call() throws Exception {
-                    return parser.Statement();
-                }
-            });
             statement = future.get(parser.getConfiguration().getAsLong(Feature.timeOut),
                     TimeUnit.MILLISECONDS);
         } catch (TimeoutException ex) {
             parser.interrupted = true;
+            future.cancel(true);
             throw new JSQLParserException("Time out occurred.", ex);
         } catch (Exception ex) {
             throw new JSQLParserException(ex);
@@ -376,17 +377,18 @@ public static Statements parseStatements(String sqls, ExecutorService executorSe
     public static Statements parseStatements(CCJSqlParser parser, ExecutorService executorService)
             throws JSQLParserException {
         Statements statements = null;
+        Future<Statements> future = executorService.submit(new Callable<Statements>() {
+            @Override
+            public Statements call() throws Exception {
+                return parser.Statements();
+            }
+        });
         try {
-            Future<Statements> future = executorService.submit(new Callable<Statements>() {
-                @Override
-                public Statements call() throws Exception {
-                    return parser.Statements();
-                }
-            });
             statements = future.get(parser.getConfiguration().getAsLong(Feature.timeOut),
                     TimeUnit.MILLISECONDS);
         } catch (TimeoutException ex) {
             parser.interrupted = true;
+            future.cancel(true);
             throw new JSQLParserException("Time out occurred.", ex);
         } catch (Exception ex) {
             throw new JSQLParserException(ex);
diff --git a/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java b/src/test/java/net/sf/jsqlparser/expression/JsonExpressionTest.java
@@ -1,3 +1,12 @@
+/*-
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2023 JSQLParser
+ * %%
+ * Dual licensed under GNU LGPL 2.1 or Apache License 2.0
+ * #L%
+ */
 package net.sf.jsqlparser.expression;
 
 import net.sf.jsqlparser.JSQLParserException;
diff --git a/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java b/src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java
@@ -36,8 +36,9 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import net.sf.jsqlparser.statement.UnsupportedStatement;
+import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.test.MemoryLeakVerifier;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
 
@@ -217,12 +218,19 @@ public void accept(Statement statement) {
     }
 
     @Test
-    @Disabled
     public void testParseStatementsFail() throws Exception {
-        // This will not fail, but always return the Unsupported Statements
-        // Since we can't LOOKAHEAD in the Statements() production
-        assertThrows(JSQLParserException.class,
-                () -> CCJSqlParserUtil.parseStatements("select * from dual;WHATEVER!!"));
+        String sqlStr = "select * from dual;WHATEVER!!";
+
+        // Won't fail but return Unsupported Statement instead
+        assertDoesNotThrow(new Executable() {
+            @Override
+            public void execute() throws Throwable {
+                final Statements statements = CCJSqlParserUtil.parseStatements(sqlStr);
+                assertEquals(2, statements.size());
+                assertTrue(statements.get(0) instanceof PlainSelect);
+                assertTrue(statements.get(1) instanceof UnsupportedStatement);
+            }
+        });
     }
 
     @Test
@@ -335,20 +343,16 @@ public void testCondExpressionIssue1482_2() throws JSQLParserException {
         assertEquals("test_table_enum.f1_enum IN ('TEST2'::test.\"test_enum\")", expr.toString());
     }
 
-
-
     /**
      * The purpose of the test is to run into a timeout and to stop the parser when this happens. We
      * provide an INVALID statement for this purpose, which will fail the SIMPLE parse and then hang
      * with COMPLEX parsing until the timeout occurs.
      * <p>
      * We repeat that test multiple times and want to see no stale references to the Parser after
      * timeout.
-     *
-     * @throws JSQLParserException
      */
     @Test
-    public void testParserInterruptedByTimeout() throws InterruptedException {
+    public void testParserInterruptedByTimeout() {
         MemoryLeakVerifier verifier = new MemoryLeakVerifier();
 
         int parallelThreads = Runtime.getRuntime().availableProcessors() + 1;
@@ -371,17 +375,15 @@ public void run() {
                 }
             });
         }
-
+        timeOutService.shutdownNow();
         executorService.shutdown();
-        timeOutService.shutdown();
 
         // we should not run in any timeout here (because we expect that the Parser has timed out by
         // itself)
         assertDoesNotThrow(new Executable() {
             @Override
             public void execute() throws Throwable {
                 executorService.awaitTermination(10, TimeUnit.SECONDS);
-                timeOutService.awaitTermination(10, TimeUnit.SECONDS);
             }
         });
 
@@ -390,7 +392,7 @@ public void execute() throws Throwable {
     }
 
     @Test
-    public void testTimeOutIssue1582() throws InterruptedException {
+    public void testTimeOutIssue1582() {
         // This statement is INVALID on purpose
         // There are crafted INTO keywords in order to make it fail but only after a long time (40
         // seconds plus)
@@ -443,7 +445,7 @@ public void execute() throws Throwable {
 
     // Supposed to time out
     @Test
-    void testComplexIssue1792() throws JSQLParserException, InterruptedException {
+    void testComplexIssue1792() throws JSQLParserException {
         ExecutorService executorService = Executors.newCachedThreadPool();
         CCJSqlParserUtil.LOGGER.setLevel(Level.ALL);
 
@@ -457,7 +459,7 @@ void testComplexIssue1792() throws JSQLParserException, InterruptedException {
             public void execute() throws Throwable {
                 try {
                     CCJSqlParserUtil.parse(INVALID_SQL, executorService, parser -> {
-                        parser.withTimeOut(6000);
+                        parser.withTimeOut(10000);
                         parser.withAllowComplexParsing(false);
                     });
                 } catch (JSQLParserException ex) {
@@ -467,7 +469,6 @@ public void execute() throws Throwable {
             }
         });
 
-
         // Expect to time-out with COMPLEX Parsing allowed
         // CCJSqlParserUtil.LOGGER will report:
         // 1) Allowed Complex Parsing: true
@@ -478,7 +479,7 @@ public void execute() throws Throwable {
             public void execute() throws Throwable {
                 try {
                     CCJSqlParserUtil.parse(INVALID_SQL, executorService, parser -> {
-                        parser.withTimeOut(6000);
+                        parser.withTimeOut(1000);
                         parser.withAllowComplexParsing(true);
                     });
                 } catch (JSQLParserException ex) {
@@ -487,9 +488,7 @@ public void execute() throws Throwable {
                 }
             }
         });
-
-        executorService.shutdown();
-        executorService.awaitTermination(1, TimeUnit.MINUTES);
+        executorService.shutdownNow();
         CCJSqlParserUtil.LOGGER.setLevel(Level.OFF);
     }
 }
