Ee merge compatible

.github/workflows/build.yml

@@ -45,5 +45,7 @@ jobs:
         if: ${{ failure() }}
         uses: actions/upload-artifact@v4
         with:
-          path: build/reports/tests/test
-          name: Test Report
+          name: test-report-${{ matrix.os }}-${{ matrix.java }}
+          path: |
+            **/build/reports/tests/test/**
+            **/build/test-results/test/*.xml

build.gradle

@@ -39,6 +39,8 @@ ext.leafProjects = leafProjects // Publish as external variable
 ext {
     sonaUser = findProperty('SONATYPE_NEXUS_USERNAME') ?:  System.getenv('SONATYPE_NEXUS_USERNAME') ?: "FakeUser"
     sonaPass = findProperty('SONATYPE_NEXUS_PASSWORD') ?:  System.getenv('SONATYPE_NEXUS_PASSWORD') ?: "FakePass"
+
+    testTags = null // Default test tags
 }
 
 // Default test categories
@@ -69,6 +71,9 @@ configure(leafProjects) {
     // Defines versions of dependencies to be used by subprojects
     // https://github.com/spring-gradle-plugins/dependency-management-plugin#dependency-management-dsl
     dependencyManagement {
+        imports {
+            mavenBom 'org.junit:junit-bom:5.14.0'
+        }
         dependencies {
             dependency ('com.epam.deltix:thread-affinity:1.0.4')
 
@@ -97,6 +102,11 @@ configure(leafProjects) {
                 entry 'jmh-core'
                 entry 'jmh-generator-annprocess'
             }
+
+            dependency 'org.jetbrains:annotations:24.1.0'
+
+            dependency "junit:junit:4.13.2"
+            dependency "org.mockito:mockito-core:5.15.2"
         }
     }
 
@@ -120,11 +130,29 @@ configure(leafProjects) {
         compileOnly 'com.google.code.findbugs:jsr305'
         compileOnly 'com.google.code.findbugs:annotations'
 
-        testImplementation 'junit:junit:4.12'
+        testCompileOnly 'junit:junit'
+
+        testImplementation "org.mockito:mockito-core"
+
+        testImplementation 'org.junit.jupiter:junit-jupiter-api'
+        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
+        testRuntimeOnly 'org.junit.vintage:junit-vintage-engine'
+        testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 
         spotbugsPlugins 'com.h3xstream.findsecbugs:findsecbugs-plugin:1.9.0'
     }
 
+    test {
+        useJUnitPlatform {
+            if (testTags != null) {
+                setIncludeTags testTags.split(',') as Set
+            }
+        }
+
+        // sync logging to not mix up messages from different tests
+        jvmArgs '-Dgflog.sync=true', '-Dgflog.console.appender.wrap=true'/*, '--add-opens', 'java.base/sun.nio.ch=ALL-UNNAMED'*/
+    }
+
     spotbugs {
         toolVersion = "3.1.12"
         effort = "max"

collections/src/main/java/com/epam/deltix/util/collections/ByteQueue.java

@@ -14,6 +14,7 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
+
 package com.epam.deltix.util.collections;
 
 import java.io.IOException;
@@ -26,8 +27,8 @@ public final class ByteQueue implements ByteContainer {
     private int                 capacity;
     private byte []             buffer;
     private int                 size = 0;
-    private int                 head = 0;
-    private int                 tail = 0;
+    private int                 head = 0; // Where data gets consumed
+    private int                 tail = 0; // Where data gets added
 
     public ByteQueue (int capacity) {
         this.capacity = capacity;
@@ -55,36 +56,6 @@ public void                 offer (byte value) {
             tail = 0;                
     }
 
-//    public void                 insert (byte [] src, int offset, int length) {
-//        if (capacity - size < length) {
-//            // increase buffer
-//            if (tail > head) {
-//                byte[] temp = new byte[capacity + length];
-//                System.arraycopy (buffer, head, temp, length + head, size);
-//                buffer = temp;
-//            } else {
-//                byte[] temp = new byte[capacity + length];
-//                System.arraycopy (buffer, 0, temp, 0, tail);
-//                System.arraycopy (buffer, head, temp, capacity - head + length, capacity - head);
-//                buffer = temp;
-//            }
-//            capacity += length;
-//        }
-//
-//        if (head > length) {
-//            System.arraycopy (src, offset, buffer, head - length, length);
-//            head -= length;
-//        } else {
-//            int remains = length - head;
-//            System.arraycopy (src, offset, buffer, capacity - remains, remains);
-//            System.arraycopy (src, offset + remains, buffer, 0, head);
-//
-//            head = capacity - remains;
-//        }
-//        size += length;
-//
-//    }
-
     public void                 offer (byte [] src, int offset, int length) {
         assert size + length <= capacity :
             "size: " + size + "; length: " + length + "; capacity: " + capacity;
@@ -93,16 +64,19 @@ public void                 offer (byte [] src, int offset, int length) {
         int                 excess = end - capacity;
 
         if (excess > 0) {
+            // Wrap over array end.
+            // Length of the first part.
             int             n = capacity - tail;
-
             System.arraycopy (src, offset, buffer, tail, n);
-
+
+            // Length of the second part.
             tail = length - n;
 
             System.arraycopy (src, offset + n, buffer, 0, tail);
         }
         else {
-            System.arraycopy (src, offset, buffer, tail, length);        
+            // Single chunk copy
+            System.arraycopy (src, offset, buffer, tail, length);
             tail = excess == 0 ? 0 : end;
         }  
 
@@ -256,7 +230,7 @@ public void                 truncate(int length) {
         assert length < size;
         int newTail = tail - length;
         if (newTail < 0)
-            newTail =+ capacity;
+            newTail += capacity;
 
         size -= length;
         tail = newTail;
@@ -267,13 +241,17 @@ public boolean              setCapacity (int value) {
             return false; 
 
         assert(value > capacity);
-        capacity = value;
 
         byte[] previous = buffer;
-        buffer = new byte[capacity];
+        // Allocate new buffer before changing any other fields to avoid state corruption if allocation fails with OOM.
+        buffer = new byte[value];
+        capacity = value;
+
         if (tail > head) {
+            // No wrap
             System.arraycopy (previous, head, buffer, 0, size);
         } else {
+            // Wrapped
             System.arraycopy (previous, head, buffer, 0, previous.length - head);
             System.arraycopy (previous, 0, buffer, previous.length - head, tail);
         }
@@ -283,4 +261,4 @@ public boolean              setCapacity (int value) {
 
         return true;
     }
-}
+}

collections/src/main/templates/RingedList.vpp

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2021 EPAM Systems, Inc
+ *
+ * See the NOTICE file distributed with this work for additional information
+ * regarding copyright ownership. Licensed under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+#if( $name == "Object" )
+#set( $type = "ObjectType" )
+#end
+package deltix.util.collections.generated;
+
+import java.util.AbstractList;
+import java.util.Arrays;
+
+public class ${name}RingedList extends AbstractList<${name}> implements ${name}List {
+
+    private static final int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;
+
+    protected ${type}[] array;
+
+    private int first, size;
+
+    public ${name}RingedList() {
+        this(0x10);
+    }
+
+    public ${name}RingedList(int capacity) {
+        if (capacity < 0) {
+            throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative");
+        }
+
+        array = new ${type}[capacity];
+        first = size = 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public ${name} get(int index) {
+        return get${name}(index);
+    }
+
+    @Override
+    public ${type} get${name}(int index) {
+        if (index > size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        return get${name}NoRangeCheck(index);
+    }
+
+    @Override
+    public ${type} get${name}NoRangeCheck(int index) {
+        index += first;
+        index = index >= array.length ? index - array.length : index;
+        return array[index];
+    }
+
+    @Override
+    public boolean add(${type} x) {
+        ensureFreeSpace(1);
+
+        int index = first + size++;
+        index = index >= array.length ? index - array.length : index;
+        array[index] = x;
+        return true;
+    }
+
+    public void set(int index, ${type} element) {
+        if (index > size) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        index += first;
+        index = index >= array.length ? index - array.length : index;
+        array[index] = element;
+    }
+
+    public ${type} first() {
+        return array[first];
+    }
+
+    public ${type} last() {
+        return get(size - 1);
+    }
+
+    public ${type} pop() {
+        ${type} res = array[first++];
+        first = first >= array.length ? first - array.length : first;
+        --size;
+
+        return res;
+    }
+
+    @Override
+    public boolean contains(${type} elem) {
+        return indexOf(elem) >= 0;
+    }
+
+    @Override
+    public int indexOf(${type} elem) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public int lastIndexOf(${type} elem) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ${type}[] to${name_abbr}Array() {
+        ${type}[] result = new ${type}[size];
+        toArray(result, 0);
+        return result;
+    }
+
+    public void toArray(${type}[] data, int offset) {
+        if (size > data.length - offset) {
+            throw new IllegalArgumentException();
+        }
+
+        for (int i = 0, j = first; i < size; ++i) {
+            data[i] = array[j++];
+            j = j == array.length ? 0 : j;
+        }
+    }
+
+    private void ensureFreeSpace(int required) {
+        long requiredCapacity = (long) size + required;
+        ensureCapacity(requiredCapacity);
+    }
+
+    public void ensureCapacity(long minCapacity) {
+        if (minCapacity > array.length) {
+            extend(minCapacity);
+        }
+    }
+
+    private void extend(long requiredCapacity) {
+        if (requiredCapacity > MAX_ARRAY_LENGTH) {
+            throw new OutOfMemoryError("required capacity=" + requiredCapacity + " exceeds max");
+        }
+
+        int newCapacity = (int) Math.min(MAX_ARRAY_LENGTH,  requiredCapacity  + (requiredCapacity >>> 1)); // 50% for growth
+
+        ${type}[] newArray = new ${type}[newCapacity];
+
+        System.arraycopy(array, first, newArray, 0, array.length - first);
+        if (first > 0) {
+            System.arraycopy(array, 0, newArray, array.length - first, first);
+        }
+        first = 0;
+        array = newArray;
+    }
+
+    @Override
+    public void clear() {
+        first = size= 0;
+    }
+
+    @Override
+    public void setSize(int newSize) {
+        ensureCapacity(newSize);
+        size = newSize;
+    }
+
+#if ($type != "boolean")
+    @Override
+    public void sort() {
+        array = to${name_abbr}Array();
+        first = 0;
+        Arrays.sort(array, 0, size);
+    }
+#end
+
+}
+
+#if( $name == "Object")
+#set( $type = "Object" )
+#end