style: reformat code

Signed-off-by: manticore-projects <andreas@manticore-projects.com>

Author: manticore-projects

src/main/java/net/sf/jsqlparser/parser/SimpleCharStream.java

@@ -328,7 +328,8 @@ public String GetImage() {
         if (bufpos >= tokenBegin) {
             return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
         } else {
-            return new String(buffer, tokenBegin, bufsize - tokenBegin) + new String(buffer, 0, bufpos + 1);
+            return new String(buffer, tokenBegin, bufsize - tokenBegin)
+                    + new String(buffer, 0, bufpos + 1);
         }
     }
 
@@ -375,10 +376,9 @@ public void adjustBeginLineColumn(int newLine, int newCol) {
         int nextColDiff;
         int columnDiff = 0;
 
-        while (
-            i < len &&
-            (int) (buflinecolumn[j = start % bufsize] >>> 32) == (int) (buflinecolumn[k = ++start % bufsize] >>> 32)
-        ) {
+        while (i < len &&
+                (int) (buflinecolumn[j = start % bufsize] >>> 32) == (int) (buflinecolumn[k =
+                        ++start % bufsize] >>> 32)) {
             int colJ = (int) buflinecolumn[j];
             int colK = (int) buflinecolumn[k];
             nextColDiff = columnDiff + colK - colJ;
@@ -394,7 +394,8 @@ public void adjustBeginLineColumn(int newLine, int newCol) {
                 int lineJ = (int) (buflinecolumn[j = start % bufsize] >>> 32);
                 int lineNext = (int) (buflinecolumn[++start % bufsize] >>> 32);
                 if (lineJ != lineNext) {
-                    buflinecolumn[j] = ((long) (newLine++) << 32) | (buflinecolumn[j] & 0xFFFFFFFFL);
+                    buflinecolumn[j] =
+                            ((long) (newLine++) << 32) | (buflinecolumn[j] & 0xFFFFFFFFL);
                 } else {
                     buflinecolumn[j] = ((long) newLine << 32) | (buflinecolumn[j] & 0xFFFFFFFFL);
                 }

src/test/java/net/sf/jsqlparser/parser/BytecodeSizeTest.java

@@ -8,34 +8,40 @@
 import org.junit.jupiter.api.Test;
 
 /**
- * Verifies that no method in the generated parser or token manager
- * exceeds the JVM's 64KB bytecode limit per method.
+ * Verifies that no method in the generated parser or token manager exceeds the JVM's 64KB bytecode
+ * limit per method.
  *
- * <p>Catches the exact failure scenario:</p>
+ * <p>
+ * Catches the exact failure scenario:
+ * </p>
+ * 
  * <pre>
  * org.objectweb.asm.MethodTooLargeException:
  *   Method too large: net/sf/jsqlparser/parser/CCJSqlParserTokenManager.&lt;clinit&gt; ()V
  * </pre>
  *
- * <p>This error occurs when bytecode instrumentation tools (JaCoCo, ASM, ByteBuddy)
- * add probes to methods that are already near the 64KB limit.  The tests therefore
- * enforce a <b>safety margin</b> ({@value #INSTRUMENTATION_HEADROOM_PERCENT}%)
- * below the hard JVM limit.</p>
+ * <p>
+ * This error occurs when bytecode instrumentation tools (JaCoCo, ASM, ByteBuddy) add probes to
+ * methods that are already near the 64KB limit. The tests therefore enforce a <b>safety margin</b>
+ * ({@value #INSTRUMENTATION_HEADROOM_PERCENT}%) below the hard JVM limit.
+ * </p>
  *
- * <p>Requires {@link BytecodeSizeVerifier} on the test classpath (same package).</p>
+ * <p>
+ * Requires {@link BytecodeSizeVerifier} on the test classpath (same package).
+ * </p>
  */
 public class BytecodeSizeTest {
 
     /**
-     * Safety margin for bytecode instrumentation (JaCoCo, ASM, etc.).
-     * Instrumentation typically adds 5-15% overhead; 20% gives comfortable headroom.
-     * A method at 80% of 64KB (52,428 bytes) will still be safe after instrumentation.
+     * Safety margin for bytecode instrumentation (JaCoCo, ASM, etc.). Instrumentation typically
+     * adds 5-15% overhead; 20% gives comfortable headroom. A method at 80% of 64KB (52,428 bytes)
+     * will still be safe after instrumentation.
      */
     private static final int INSTRUMENTATION_HEADROOM_PERCENT = 20;
 
     /**
-     * Hard fail threshold: 100% minus instrumentation headroom.
-     * Methods exceeding this will likely break under JaCoCo/ASM instrumentation.
+     * Hard fail threshold: 100% minus instrumentation headroom. Methods exceeding this will likely
+     * break under JaCoCo/ASM instrumentation.
      */
     private static final int FAIL_PERCENT = 100 - INSTRUMENTATION_HEADROOM_PERCENT;
 
@@ -48,33 +54,36 @@ public class BytecodeSizeTest {
             (int) (BytecodeSizeVerifier.JVM_CODE_LIMIT * (FAIL_PERCENT / 100.0));
 
     /**
-     * The generated parser/token manager classes to check.
-     * Inner classes (e.g. CharDataConsts) are checked automatically
-     * since we scan the entire classes directory.
+     * The generated parser/token manager classes to check. Inner classes (e.g. CharDataConsts) are
+     * checked automatically since we scan the entire classes directory.
      */
     private static final List<String> CRITICAL_CLASSES = List.of(
             "CCJSqlParser",
-            "CCJSqlParserTokenManager"
-    );
+            "CCJSqlParserTokenManager");
 
     // -----------------------------------------------------------------------
     // Test: clinit specifically (matches the reported ASM error)
     // -----------------------------------------------------------------------
 
     /**
      * Reproduces the exact failure scenario:
+     * 
      * <pre>
      * org.objectweb.asm.MethodTooLargeException:
      *   Method too large: net/sf/jsqlparser/parser/CCJSqlParserTokenManager.&lt;clinit&gt; ()V
      * </pre>
      *
-     * <p>Checks {@code <clinit>} in all parser-related classes (including inner classes
-     * like {@code CharDataConsts}) against the instrumentation-safe threshold.</p>
+     * <p>
+     * Checks {@code <clinit>} in all parser-related classes (including inner classes like
+     * {@code CharDataConsts}) against the instrumentation-safe threshold.
+     * </p>
      */
     @Test
     void clinitMustFitWithinInstrumentationSafeLimit() throws Exception {
         List<BytecodeSizeVerifier.Result> results = scanParserClasses();
-        if (results.isEmpty()) return; // skip if classes not found
+        if (results.isEmpty()) {
+            return; // skip if classes not found
+        }
 
         List<String> failures = new ArrayList<>();
 
@@ -87,33 +96,37 @@ void clinitMustFitWithinInstrumentationSafeLimit() throws Exception {
                 if (r.clinitSize > FAIL_THRESHOLD) {
                     failures.add(String.format(
                             "%s.<clinit>: %,d bytes (%.1f%%) exceeds %d%% safe limit.\n"
-                            + "  ASM/JaCoCo instrumentation will push this over 64KB.\n"
-                            + "  Fix: move static array initializers to _init() methods.",
+                                    + "  ASM/JaCoCo instrumentation will push this over 64KB.\n"
+                                    + "  Fix: move static array initializers to _init() methods.",
                             r.className, r.clinitSize, pct, FAIL_PERCENT));
                 }
             }
         }
 
         assertTrue(failures.isEmpty(),
                 "Static initializer(s) too large for safe instrumentation:\n"
-                + String.join("\n", failures));
+                        + String.join("\n", failures));
     }
 
     // -----------------------------------------------------------------------
     // Test: all methods (general code-too-large prevention)
     // -----------------------------------------------------------------------
 
     /**
-     * Checks every method in the generated parser and token manager classes
-     * against the instrumentation-safe threshold.
+     * Checks every method in the generated parser and token manager classes against the
+     * instrumentation-safe threshold.
      *
-     * <p>Covers: production methods, jj_3R_* lookahead scanners,
-     * jj_rescan_token, jj_la1_init_*, and all other generated methods.</p>
+     * <p>
+     * Covers: production methods, jj_3R_* lookahead scanners, jj_rescan_token, jj_la1_init_*, and
+     * all other generated methods.
+     * </p>
      */
     @Test
     void allMethodsMustFitWithinInstrumentationSafeLimit() throws Exception {
         List<BytecodeSizeVerifier.Result> results = scanParserClasses();
-        if (results.isEmpty()) return;
+        if (results.isEmpty()) {
+            return;
+        }
 
         List<String> failures = new ArrayList<>();
         int totalMethods = 0;
@@ -144,16 +157,16 @@ void allMethodsMustFitWithinInstrumentationSafeLimit() throws Exception {
 
         assertTrue(failures.isEmpty(),
                 failures.size() + " method(s) too large for safe instrumentation:\n"
-                + String.join("\n", failures));
+                        + String.join("\n", failures));
     }
 
     // -----------------------------------------------------------------------
     // Test: named critical classes must be found
     // -----------------------------------------------------------------------
 
     /**
-     * Ensures the critical parser classes actually exist in the build output.
-     * Catches misconfigured build paths that would silently skip all checks.
+     * Ensures the critical parser classes actually exist in the build output. Catches misconfigured
+     * build paths that would silently skip all checks.
      */
     @Test
     void criticalClassesMustBePresent() throws Exception {
@@ -170,7 +183,7 @@ void criticalClassesMustBePresent() throws Exception {
             }
             assertTrue(found,
                     className + ".class not found under " + classesDir
-                    + " — check build configuration");
+                            + " — check build configuration");
         }
     }
 
@@ -184,7 +197,8 @@ void criticalClassesMustBePresent() throws Exception {
     private List<BytecodeSizeVerifier.Result> scanParserClasses() throws Exception {
         Path classesDir = findClassesDir();
         if (classesDir == null) {
-            System.err.println("WARNING: compiled classes directory not found, skipping bytecode checks");
+            System.err.println(
+                    "WARNING: compiled classes directory not found, skipping bytecode checks");
             return Collections.emptyList();
         }
 
@@ -196,8 +210,7 @@ private List<BytecodeSizeVerifier.Result> scanParserClasses() throws Exception {
     }
 
     /**
-     * Locate the compiled classes directory.
-     * Tries standard Gradle and Maven layouts.
+     * Locate the compiled classes directory. Tries standard Gradle and Maven layouts.
      */
     private Path findClassesDir() {
         // Try to infer from this test class's own location
@@ -217,14 +230,16 @@ private Path findClassesDir() {
         }
 
         // Fallback: standard locations relative to working directory
-        for (String candidate : new String[]{
+        for (String candidate : new String[] {
                 "build/classes/java/main",
                 "target/classes",
                 "build/classes/main",
                 "out/production/classes"
         }) {
             Path p = Path.of(candidate);
-            if (Files.isDirectory(p)) return p;
+            if (Files.isDirectory(p)) {
+                return p;
+            }
         }
         return null;
     }

src/test/java/net/sf/jsqlparser/parser/BytecodeSizeVerifier.java

@@ -7,18 +7,16 @@
 import java.util.stream.*;
 
 /**
- * Zero-dependency bytecode verifier that scans compiled .class files
- * and reports methods approaching or exceeding the JVM 64KB code size limit.
+ * Zero-dependency bytecode verifier that scans compiled .class files and reports methods
+ * approaching or exceeding the JVM 64KB code size limit.
  *
- * Also checks clinit (static initializer) sizes separately since
- * large static initializers are a common problem with generated parsers.
+ * Also checks clinit (static initializer) sizes separately since large static initializers are a
+ * common problem with generated parsers.
  *
- * Usage as standalone tool:
- *   java BytecodeSizeVerifier path/to/classes [--warn-pct 75] [--fail]
+ * Usage as standalone tool: java BytecodeSizeVerifier path/to/classes [--warn-pct 75] [--fail]
  *
- * Usage as library (from JUnit test):
- *   BytecodeSizeVerifier.Result r = BytecodeSizeVerifier.verify(classFile, 80);
- *   assertTrue(r.violations.isEmpty(), r.report());
+ * Usage as library (from JUnit test): BytecodeSizeVerifier.Result r =
+ * BytecodeSizeVerifier.verify(classFile, 80); assertTrue(r.violations.isEmpty(), r.report());
  */
 public class BytecodeSizeVerifier {
 
@@ -113,7 +111,8 @@ public String toString() {
 
     /**
      * Verify a single .class file.
-     * @param classFile   path to the .class file
+     * 
+     * @param classFile path to the .class file
      * @param warnPercent warn when method exceeds this % of the 64KB limit (e.g. 75)
      */
     public static Result verify(Path classFile, int warnPercent) throws IOException {
@@ -123,11 +122,13 @@ public static Result verify(Path classFile, int warnPercent) throws IOException
 
     /**
      * Verify class bytes directly.
-     * @param name        descriptive name for reporting
-     * @param classBytes  raw .class file bytes
+     * 
+     * @param name descriptive name for reporting
+     * @param classBytes raw .class file bytes
      * @param warnPercent warn threshold (0-100)
      */
-    public static Result verify(String name, byte[] classBytes, int warnPercent) throws IOException {
+    public static Result verify(String name, byte[] classBytes, int warnPercent)
+            throws IOException {
         DataInputStream in = new DataInputStream(new ByteArrayInputStream(classBytes));
 
         int magic = in.readInt();
@@ -149,21 +150,31 @@ public static Result verify(String name, byte[] classBytes, int warnPercent) thr
                 case 1: // CONSTANT_Utf8
                     cpUtf8[i] = in.readUTF();
                     break;
-                case 3: case 4: // Integer, Float
+                case 3:
+                case 4: // Integer, Float
                     in.readInt();
                     break;
-                case 5: case 6: // Long, Double
+                case 5:
+                case 6: // Long, Double
                     in.readLong();
                     i++; // takes two CP slots
                     break;
                 case 7: // CONSTANT_Class
                     cpClassNameIdx[i] = in.readUnsignedShort();
                     break;
-                case 8: case 16: case 19: case 20:
+                case 8:
+                case 16:
+                case 19:
+                case 20:
                     // String, MethodType, Module, Package
                     in.readUnsignedShort();
                     break;
-                case 9: case 10: case 11: case 12: case 17: case 18:
+                case 9:
+                case 10:
+                case 11:
+                case 12:
+                case 17:
+                case 18:
                     // Fieldref, Methodref, InterfaceMethodref, NameAndType, Dynamic, InvokeDynamic
                     in.readUnsignedShort();
                     in.readUnsignedShort();
@@ -173,7 +184,8 @@ public static Result verify(String name, byte[] classBytes, int warnPercent) thr
                     in.readUnsignedShort();
                     break;
                 default:
-                    throw new IOException("Unknown CP tag: " + tag + " at index " + i + " in " + name);
+                    throw new IOException(
+                            "Unknown CP tag: " + tag + " at index " + i + " in " + name);
             }
         }
 
@@ -194,7 +206,9 @@ public static Result verify(String name, byte[] classBytes, int warnPercent) thr
         in.readUnsignedShort(); // super class
 
         int ifCount = in.readUnsignedShort();
-        for (int i = 0; i < ifCount; i++) in.readUnsignedShort();
+        for (int i = 0; i < ifCount; i++) {
+            in.readUnsignedShort();
+        }
 
         // Fields - skip
         int fieldCount = in.readUnsignedShort();
@@ -244,7 +258,8 @@ public static List<Result> verifyDirectory(Path dir, int warnPercent) throws IOE
         List<Result> results = new ArrayList<>();
         Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
             @Override
-            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                    throws IOException {
                 if (file.toString().endsWith(".class")) {
                     results.add(verify(file, warnPercent));
                 }
@@ -343,7 +358,9 @@ public static void main(String[] args) throws Exception {
         for (Result result : results) {
             if (!result.violations.isEmpty() || !result.warnings.isEmpty()) {
                 System.out.println(result.report());
-                if (!result.violations.isEmpty()) hasViolations = true;
+                if (!result.violations.isEmpty()) {
+                    hasViolations = true;
+                }
             }
         }
 

src/test/java/net/sf/jsqlparser/parser/CCJSqlParserUtilTest.java

@@ -408,7 +408,7 @@ public void execute() throws Throwable {
 
     @Test
     @Disabled
-    //@todo: check if this still has a chance to timeout since we got too fast
+    // @todo: check if this still has a chance to timeout since we got too fast
     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

src/test/java/net/sf/jsqlparser/test/TestUtils.java

@@ -373,8 +373,7 @@ public static void assertExpressionCanBeParsedAndDeparsed(String expressionStr,
             Expression expression = CCJSqlParserUtil.parseExpression(expressionStr);
             assertEquals(
                     buildSqlString(expressionStr, laxDeparsingCheck),
-                    buildSqlString(expression.toString(), laxDeparsingCheck)
-            );
+                    buildSqlString(expression.toString(), laxDeparsingCheck));
         } catch (JSQLParserException ex) {
             throw new JSQLParserException(expressionStr, ex);
         }