feat: added tests for #385

Author: U117293

Diff for: java/src/main/java/io/cucumber/gherkin/Locations.java

@@ -12,14 +12,14 @@ class Locations {
      * We can't use Long.valueOf() because it caches only the first 128
      * values, and typical feature files have much more lines.
      */
-    private final static Long[] longs = new Long[4000];
+    private static final Long[] longs = new Long[4096];
     static {
         for (int i = 0; i < longs.length; i++) {
             longs[i] = (long) i;
         }
     }
 
-    private static Long getLong(int i) {
+    static Long getLong(int i) {
         if (i>=longs.length) return (long) i;
         return longs[i];
     }

Diff for: java/src/test/java/io/cucumber/gherkin/LocationsTest.java

@@ -0,0 +1,57 @@
+package io.cucumber.gherkin;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LocationsTest {
+
+    @Test
+    void getLong() {
+        // random integer conversion that is far after the cache upper bound works
+        assertEquals(Long.valueOf(12000L), Locations.getLong(12000));
+
+        // sequential integer conversion works (the cache has no hole)
+        for (int i=0; i<12000; i++) {
+            Long expectedLong = (long)i;
+            assertEquals(expectedLong, Locations.getLong(i));
+        }
+    }
+
+    @Test
+    void getLong_negative_number_not_supported() {
+        assertThrows(ArrayIndexOutOfBoundsException.class, () -> Locations.getLong(-12000));
+    }
+
+    @Test
+    void getLong_multithread_does_not_raise_exception() {
+        // Given
+        AtomicInteger successCounter = new AtomicInteger(0);
+        int numberOfThreads = 1000;
+        int numberOfIterations = 20000;
+        Thread[] threads = new Thread[numberOfThreads];
+        for (int i = 0; i < numberOfThreads; i++) {
+            threads[i] = new Thread(() -> {
+                for (int j = 500; j < numberOfIterations; j *= 2) {
+                    Long expectedLong = (long)j;
+                    assertEquals(expectedLong, Locations.getLong(j));
+                }
+                successCounter.incrementAndGet();
+            });
+        }
+
+        // When
+        for (Thread thread : threads) {
+            thread.start();
+        }
+
+        // Then
+        for (Thread thread : threads) {
+            assertDoesNotThrow(() -> thread.join());
+        }
+        assertEquals(numberOfThreads, successCounter.get());
+    }
+
+}