Adv/add jaccoco

src/main/java/net/openhft/chronicle/bytes/AbstractBytes.java

@@ -72,7 +72,7 @@ public abstract class AbstractBytes<U>
 
     private final UncheckedRandomDataInput uncheckedRandomDataInput = new UncheckedRandomDataInputHolder();
     @NotNull
-    protected BytesStore<?, U> bytesStore;
+    protected BytesStore<?, U> bytesStore = BytesStore.empty();
     /** Offset, from {@link #start()}, of the next byte to read. */
     protected long readPosition;
     /** Highest byte index that may be written. */
@@ -116,7 +116,7 @@ public abstract class AbstractBytes<U>
                   @NonNegative long writeLimit,
                   String name)
             throws ClosedIllegalStateException, ThreadingIllegalStateException {
-        super(bytesStore.isDirectMemory());
+        super(java.util.Objects.requireNonNull(bytesStore, "bytesStore").isDirectMemory());
         this.bytesStore(bytesStore);
         bytesStore.reserve(this);
         readPosition = bytesStore.readPosition();

src/main/java/net/openhft/chronicle/bytes/BinaryBytesMethodWriterInvocationHandler.java

@@ -54,7 +54,7 @@ protected Object doInvoke(Object proxy, Method method, Object[] args)
                 out.writeHexDumpDescription(method.getName());
                 out.writeStopBit(info.messageId());
                 info.encode(args, out);
-            } catch (Throwable t) {
+            } catch (Throwable t) { // restore previous behaviour: always roll back position on any failure
                 out.writePosition(pos);
                 throw t;
             }

src/main/java/net/openhft/chronicle/bytes/BytesMarshallable.java

@@ -57,8 +57,10 @@ default void writeMarshallable(BytesOut<?> bytes)
             String s = "# " + getClass().getName() + "\n" + bytes.toHexString();
             bytes.releaseLast();
             return s;
-        } catch (Throwable e) {
+        } catch (Exception e) {
             return e.toString();
+        } catch (Error err) {
+            throw err;
         } finally {
             ValidatableUtil.endValidateDisabled();
         }

src/main/java/net/openhft/chronicle/bytes/BytesMarshaller.java

@@ -36,6 +36,12 @@ public class BytesMarshaller<T> {
     public static final ClassLocal<BytesMarshaller> BYTES_MARSHALLER_CL
             = ClassLocal.withInitial(BytesMarshaller::new);
     private final FieldAccess[] fields;
+    /**
+     * Controls whether private fields are included via reflective access. When disabled, only
+     * publicly accessible fields are marshalled. This avoids reflective accessibility changes in
+     * restricted runtimes.
+     */
+    static final boolean ALLOW_PRIVATE_FIELD_ACCESS = Jvm.getBoolean("bytes.marshaller.allowPrivateFields", true);
 
     /**
      * Constructs a BytesMarshaller for the specified class.
@@ -63,11 +69,30 @@ public static void getAllField(@NotNull Class<?> clazz, @NotNull Map<String, Fie
         for (@NotNull Field field : clazz.getDeclaredFields()) {
             if ((field.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) != 0)
                 continue;
-            Jvm.setAccessible(field);
-            map.put(field.getName(), field);
+            if (ALLOW_PRIVATE_FIELD_ACCESS) {
+                // Intentionally limited and documented reflective access for marshalling private fields.
+                // This is centralised here to keep the surface small and auditable.
+                enableAccessible(field);
+                map.put(field.getName(), field);
+            } else {
+                // Only marshal fields that are already publicly accessible when private access is disabled.
+                final boolean publicField = Modifier.isPublic(field.getModifiers());
+                final boolean publicClass = Modifier.isPublic(field.getDeclaringClass().getModifiers());
+                if (publicField && publicClass) {
+                    map.put(field.getName(), field);
+                }
+            }
         }
     }
 
+    /**
+     * Centralised, narrowly-scoped accessibility change with explicit suppression and justification.
+     */
+    @SuppressWarnings("java:S3011")
+    private static void enableAccessible(Field field) {
+        Jvm.setAccessible(field);
+    }
+
     /**
      * Populates {@code t} by reading each field from {@code in} using reflection.
      */
@@ -331,8 +356,10 @@ protected void setValue(Object o, BytesIn<?> read)
             if (c == null) {
                 c = (Object[]) Array.newInstance(field.getType().getComponentType(), elementCount);
                 field.set(o, c);
-            } else if (c.length != elementCount)
-                field.set(o, c = Arrays.copyOf(c, elementCount));
+            } else if (c.length != elementCount) {
+                c = Arrays.copyOf(c, elementCount);
+                field.set(o, c);
+            }
             for (int i = 0; i < elementCount; i++) {
                 Object o2 = c[i];
                 if (o2 instanceof BytesMarshallable)
@@ -405,8 +432,10 @@ protected void setValue(Object o, BytesIn<?> read)
             }
             BytesUtil.checkArrayLength(length, read.readRemaining());
 
-            if (c == null)
-                field.set(o, c = collectionSupplier.get());
+            if (c == null) {
+                c = collectionSupplier.get();
+                field.set(o, c);
+            }
             else
                 c.clear();
 
@@ -473,7 +502,8 @@ protected void setValue(Object o, BytesIn<?> read)
             }
             BytesUtil.checkArrayLength(numEntries, read.readRemaining());
             if (m == null) {
-                field.set(o, m = collectionSupplier.get());
+                m = collectionSupplier.get();
+                field.set(o, m);
             } else {
                 m.clear();
             }

src/main/java/net/openhft/chronicle/bytes/HexDumpBytes.java

@@ -168,8 +168,10 @@ public String toHexString() {
             throwExceptionIfReleased(this);
             if (lineLength() > 0) newLine();
             return text.toString();
-        } catch (Throwable e) {
+        } catch (Exception e) {
             return e.toString();
+        } catch (Error err) {
+            throw err;
         }
     }
 

src/main/java/net/openhft/chronicle/bytes/RandomDataInput.java

@@ -552,28 +552,9 @@ default <T extends Appendable & CharSequence> long readUtf8Limited(@NonNegative
         long remaining = requireNonNegative(readLimit() - offset);
         if (remaining < 1)
             throw new BufferUnderflowException();
-
-        long utfLen;
-        if ((utfLen = readByte(offset++)) < 0) {
-            utfLen &= 0x7FL;
-            long b;
-            int count = 7;
-            while ((b = readByte(offset++)) < 0) {
-                utfLen |= (b & 0x7FL) << count;
-                count += 7;
-            }
-            if (b != 0) {
-                if (count > 56)
-                    throw new IORuntimeException(
-                            "Cannot read more than 9 stop bits of positive value");
-                utfLen |= (b << count);
-            } else {
-                if (count > 63)
-                    throw new IORuntimeException(
-                            "Cannot read more than 10 stop bits of negative value");
-                utfLen = ~utfLen;
-            }
-        }
+        StopBitDecoded decoded = decodeStopBit(this, offset);
+        long utfLen = decoded.value;
+        offset = decoded.nextOffset;
         if (utfLen == -1)
             return ~offset;
         if (utfLen > maxUtf8Len)
@@ -585,6 +566,39 @@ default <T extends Appendable & CharSequence> long readUtf8Limited(@NonNegative
         return offset + utfLen;
     }
 
+    /** Minimal holder for a decoded stop-bit value and the next offset. */
+    final class StopBitDecoded {
+        public final long value;
+        public final long nextOffset;
+        StopBitDecoded(long value, long nextOffset) {
+            this.value = value;
+            this.nextOffset = nextOffset;
+        }
+    }
+
+    static StopBitDecoded decodeStopBit(@NotNull RandomDataInput in, long offset)
+            throws IORuntimeException, ClosedIllegalStateException {
+        long v = in.readByte(offset++);
+        if (v >= 0) return new StopBitDecoded(v, offset);
+        v &= 0x7FL;
+        long b;
+        int count = 7;
+        while ((b = in.readByte(offset++)) < 0) {
+            v |= (b & 0x7FL) << count;
+            count += 7;
+        }
+        if (b != 0) {
+            if (count > 56)
+                throw new IORuntimeException("Cannot read more than 9 stop bits of positive value");
+            v |= (b << count);
+        } else {
+            if (count > 63)
+                throw new IORuntimeException("Cannot read more than 10 stop bits of negative value");
+            v = ~v;
+        }
+        return new StopBitDecoded(v, offset);
+    }
+
     /**
      * Reads a char sequence from the given {@code offset}, encoded as Utf8. If length of Utf8
      * encoding of the char sequence exceeds {@code maxUtf8Len}, {@code ClosedIllegalStateException}

src/main/java/net/openhft/chronicle/bytes/internal/ByteBuffers.java

@@ -29,8 +29,8 @@ private ByteBuffers() {
         try {
             address = Jvm.getField(direct.getClass(), "address");
             capacity = Jvm.getField(direct.getClass(), "capacity");
-        } catch (Throwable t) {
-            Jvm.warn().on(ByteBuffers.class, "Unable to access direct ByteBuffer fields", t);
+        } catch (Exception e) {
+            Jvm.warn().on(ByteBuffers.class, "Unable to access direct ByteBuffer fields", e);
         }
         ADDRESS = address;
         CAPACITY = capacity;

src/main/java/net/openhft/chronicle/bytes/internal/BytesInternal.java

@@ -224,12 +224,18 @@ private static Boolean java11ContentEqualUsingVectorizedMismatch(@NotNull final
             }
 
             final int length = (int) left.realReadRemaining();
-            final int invoke = (int) VECTORIZED_MISMATCH_METHOD_HANDLE.invoke(leftObject,
-                    leftOffset,
-                    rightObject,
-                    rightOffset,
-                    length,
-                    0);
+            final int invoke;
+            try {
+                invoke = (int) VECTORIZED_MISMATCH_METHOD_HANDLE.invoke(leftObject,
+                        leftOffset,
+                        rightObject,
+                        rightOffset,
+                        length,
+                        0);
+            } catch (Throwable t) { // MethodHandle.invoke declares Throwable
+                Jvm.warn().on(BytesInternal.class, t);
+                return null;
+            }
 
             if (invoke >= 0)
                 return Boolean.FALSE;
@@ -244,9 +250,11 @@ private static Boolean java11ContentEqualUsingVectorizedMismatch(@NotNull final
             }
 
             return Boolean.TRUE;
-        } catch (Throwable e) {
+        } catch (Exception e) {
             Jvm.warn().on(BytesInternal.class, e);
             return null;
+        } catch (Error err) {
+            throw err;
         }
     }
 

src/main/java/net/openhft/chronicle/bytes/internal/NativeBytesStore.java

@@ -55,8 +55,8 @@ public class NativeBytesStore<U>
             address = Jvm.getField(directBB, "address");
             capacity = Jvm.getField(directBB, "capacity");
             att = Jvm.getField(directBB, "att");
-        } catch (Throwable t) {
-            Jvm.warn().on(NativeBytesStore.class, "Unable to access ByteBuffer fields", t);
+        } catch (Exception e) {
+            Jvm.warn().on(NativeBytesStore.class, "Unable to access ByteBuffer fields", e);
         }
         BB_ADDRESS = address;
         BB_CAPACITY = capacity;

src/main/java/net/openhft/chronicle/bytes/ref/BinaryIntReference.java

@@ -89,8 +89,10 @@ public String toString() {
             return "bytes is null";
         try {
             return "value: " + getValue();
-        } catch (Throwable e) {
+        } catch (Exception e) {
             return "value: " + e;
+        } catch (Error err) {
+            throw err;
         }
     }
 

src/main/java/net/openhft/chronicle/bytes/ref/BinaryLongArrayReference.java

@@ -411,8 +411,10 @@ public String toString() {
             if (i < getCapacity())
                 sb.append(" ...");
 
-        } catch (Throwable e) {
+        } catch (Exception e) {
             sb.append(" ").append(e);
+        } catch (Error err) {
+            throw err;
         }
         return sb.toString();
     }

src/main/java/net/openhft/chronicle/bytes/ref/BinaryLongReference.java

@@ -83,8 +83,10 @@ public String toString() {
         if (bytesStore == null) return "bytes is null";
         try {
             return "value: " + getValue();
-        } catch (Throwable e) {
+        } catch (Exception e) {
             return e.toString();
+        } catch (Error err) {
+            throw err;
         }
     }
 

src/main/java/net/openhft/chronicle/bytes/ref/UncheckedLongReference.java

@@ -106,8 +106,10 @@ public String toString() {
             return "addressForRead is 0";
         try {
             return "value: " + getValue();
-        } catch (Throwable e) {
+        } catch (Exception e) {
             return "value: " + e;
+        } catch (Error err) {
+            throw err;
         }
     }