[Java] Extend property-based tests to exercise Java DTOs.

The added test (non-exhaustively) checks the property:

```
∀ msg ∈ MessageSchemas,
∀ encoding ∈ EncodingsOf(msg),
encoding = dtoEncode(dtoDecode(encoding))
```

The added test shows some compilation failures, which need to be
resolved before enabling it.

Author: ZachBray

sbe-tool/src/main/java/uk/co/real_logic/sbe/generation/java/JavaGenerator.java

@@ -160,6 +160,7 @@ public JavaGenerator(
     {
         Verify.notNull(ir, "ir");
         Verify.notNull(outputManager, "outputManager");
+        Verify.notNull(precedenceChecks, "precedenceChecks");
 
         this.ir = ir;
         this.shouldSupportTypesPackageNames = shouldSupportTypesPackageNames;

sbe-tool/src/propertyTest/java/uk/co/real_logic/sbe/properties/DtosPropertyTest.java

@@ -13,28 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package uk.co.real_logic.sbe.properties;
 
 import net.jqwik.api.*;
+import uk.co.real_logic.sbe.generation.common.PrecedenceChecks;
 import uk.co.real_logic.sbe.generation.cpp.CppDtoGenerator;
 import uk.co.real_logic.sbe.generation.cpp.CppGenerator;
 import uk.co.real_logic.sbe.generation.cpp.NamespaceOutputManager;
 import uk.co.real_logic.sbe.generation.csharp.CSharpDtoGenerator;
 import uk.co.real_logic.sbe.generation.csharp.CSharpGenerator;
 import uk.co.real_logic.sbe.generation.csharp.CSharpNamespaceOutputManager;
+import uk.co.real_logic.sbe.generation.java.JavaDtoGenerator;
+import uk.co.real_logic.sbe.generation.java.JavaGenerator;
+import uk.co.real_logic.sbe.ir.generated.MessageHeaderDecoder;
 import uk.co.real_logic.sbe.properties.arbitraries.SbeArbitraries;
+import uk.co.real_logic.sbe.properties.utils.InMemoryOutputManager;
+import org.agrona.DirectBuffer;
+import org.agrona.ExpandableArrayBuffer;
 import org.agrona.IoUtil;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
 import org.agrona.io.DirectBufferInputStream;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URLClassLoader;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
 
+import static uk.co.real_logic.sbe.SbeTool.JAVA_DEFAULT_DECODING_BUFFER_TYPE;
+import static uk.co.real_logic.sbe.SbeTool.JAVA_DEFAULT_ENCODING_BUFFER_TYPE;
+
 @SuppressWarnings("ReadWriteStringCanBeUsed")
 public class DtosPropertyTest
 {
@@ -44,6 +58,101 @@ public class DtosPropertyTest
     private static final String CPP_EXECUTABLE = System.getProperty("sbe.tests.cpp.executable", "g++");
     private static final boolean KEEP_DIR_ON_FAILURE = Boolean.parseBoolean(
         System.getProperty("sbe.tests.keep.dir.on.failure", "true"));
+    private final ExpandableArrayBuffer outputBuffer = new ExpandableArrayBuffer();
+
+//    @Test
+//    void oneRun() throws IOException, ClassNotFoundException, InvocationTargetException, NoSuchMethodException,
+//        IllegalAccessException
+//    {
+//        javaDtoEncodeShouldBeTheInverseOfDtoDecode(encodedMessage().sample());
+//    }
+
+    @Property
+    @Disabled
+    void javaDtoEncodeShouldBeTheInverseOfDtoDecode(
+        @ForAll("encodedMessage") final SbeArbitraries.EncodedMessage encodedMessage
+    ) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
+        IllegalAccessException
+    {
+        final String packageName = encodedMessage.ir().applicableNamespace();
+        final InMemoryOutputManager outputManager = new InMemoryOutputManager(packageName);
+
+        boolean success = false;
+
+        try
+        {
+            try
+            {
+                new JavaGenerator(
+                    encodedMessage.ir(),
+                    JAVA_DEFAULT_ENCODING_BUFFER_TYPE,
+                    JAVA_DEFAULT_DECODING_BUFFER_TYPE,
+                    false,
+                    false,
+                    false,
+                    false,
+                    PrecedenceChecks.newInstance(new PrecedenceChecks.Context()),
+                    outputManager)
+                    .generate();
+
+                new JavaDtoGenerator(encodedMessage.ir(), outputManager)
+                    .generate();
+            }
+            catch (final Exception generationException)
+            {
+                throw new AssertionError(
+                    "Code generation failed.\n\n" +
+                        "SCHEMA:\n" + encodedMessage.schema(),
+                    generationException);
+            }
+
+            try (URLClassLoader generatedClassLoader = outputManager.compileGeneratedSources())
+            {
+                final Class<?> dtoClass =
+                    generatedClassLoader.loadClass(packageName + ".TestMessageDto");
+
+                final Method decodeFrom =
+                    dtoClass.getMethod("decodeFrom", DirectBuffer.class, int.class, short.class, short.class);
+
+                final Method encodeWith =
+                    dtoClass.getMethod("encodeWithHeaderWith", dtoClass, MutableDirectBuffer.class, int.class);
+
+                final int inputLength = encodedMessage.length();
+                final ExpandableArrayBuffer inputBuffer = encodedMessage.buffer();
+                final MessageHeaderDecoder header = new MessageHeaderDecoder().wrap(inputBuffer, 0);
+                final short blockLength = (short)header.blockLength();
+                final short actingVersion = (short)header.version();
+                final Object dto = decodeFrom.invoke(null,
+                    encodedMessage.buffer(), MessageHeaderDecoder.ENCODED_LENGTH, blockLength, actingVersion);
+                outputBuffer.setMemory(0, outputBuffer.capacity(), (byte)0);
+                final int outputLength = (int)encodeWith.invoke(null, dto, outputBuffer, 0);
+                if (!areEqual(inputBuffer, inputLength, outputBuffer, outputLength))
+                {
+                    throw new AssertionError(
+                        "Input and output differ\n\n" +
+                            "SCHEMA:\n" + encodedMessage.schema());
+                }
+
+                success = true;
+            }
+        }
+        finally
+        {
+            if (!success)
+            {
+                outputManager.dumpSources();
+            }
+        }
+    }
+
+    private boolean areEqual(
+        final ExpandableArrayBuffer inputBuffer,
+        final int inputLength,
+        final ExpandableArrayBuffer outputBuffer,
+        final int outputLength)
+    {
+        return new UnsafeBuffer(inputBuffer, 0, inputLength).equals(new UnsafeBuffer(outputBuffer, 0, outputLength));
+    }
 
     @Property
     void csharpDtoEncodeShouldBeTheInverseOfDtoDecode(
@@ -274,4 +383,5 @@ private static void copyResourceToFile(
             throw new RuntimeException(e);
         }
     }
+
 }

sbe-tool/src/propertyTest/java/uk/co/real_logic/sbe/properties/utils/InMemoryOutputManager.java

@@ -0,0 +1,207 @@
+/*
+ * Copyright 2013-2024 Real Logic Limited.
+ *
+ * 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
+ *
+ * https://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.
+ */
+
+package uk.co.real_logic.sbe.properties.utils;
+
+import org.agrona.generation.DynamicPackageOutputManager;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.*;
+import javax.tools.*;
+
+/**
+ * An implementation of {@link DynamicPackageOutputManager} that stores generated source code in memory and compiles it
+ * on demand.
+ */
+public class InMemoryOutputManager implements DynamicPackageOutputManager
+{
+    private final String packageName;
+    private final Map<String, InMemoryJavaFileObject> sourceFiles = new HashMap<>();
+    private String packageNameOverride;
+
+    public InMemoryOutputManager(final String packageName)
+    {
+        this.packageName = packageName;
+    }
+
+    @Override
+    public Writer createOutput(final String name)
+    {
+        return new InMemoryWriter(name);
+    }
+
+    @Override
+    public void setPackageName(final String packageName)
+    {
+        packageNameOverride = packageName;
+    }
+
+    /**
+     * Compile the generated sources and return a {@link URLClassLoader} that can be used to load the generated classes.
+     *
+     * @return a {@link URLClassLoader} that can be used to load the generated classes
+     */
+    public URLClassLoader compileGeneratedSources()
+    {
+        final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+        final StandardJavaFileManager standardFileManager = compiler.getStandardFileManager(null, null, null);
+        final InMemoryFileManager fileManager = new InMemoryFileManager(standardFileManager);
+        final JavaCompiler.CompilationTask task = compiler.getTask(
+            null,
+            fileManager,
+            null,
+            null,
+            null,
+            sourceFiles.values()
+        );
+
+        if (!task.call())
+        {
+            throw new IllegalStateException("Compilation failed");
+        }
+
+        final GeneratedCodeLoader classLoader = new GeneratedCodeLoader(getClass().getClassLoader());
+        classLoader.defineClasses(fileManager);
+        return classLoader;
+    }
+
+    public void dumpSources()
+    {
+        sourceFiles.forEach((qualifiedName, file) ->
+        {
+            System.out.println(
+                System.lineSeparator() + "Source file: " + qualifiedName +
+                System.lineSeparator() + file.sourceCode +
+                System.lineSeparator());
+        });
+    }
+
+    class InMemoryWriter extends StringWriter
+    {
+        private final String name;
+
+        InMemoryWriter(final String name)
+        {
+            this.name = name;
+        }
+
+        @Override
+        public void close() throws IOException
+        {
+            super.close();
+            final String actingPackageName = packageNameOverride == null ? packageName : packageNameOverride;
+            packageNameOverride = null;
+
+            final String qualifiedName = actingPackageName + "." + name;
+            final InMemoryJavaFileObject sourceFile =
+                new InMemoryJavaFileObject(qualifiedName, getBuffer().toString());
+
+            final InMemoryJavaFileObject existingFile = sourceFiles.putIfAbsent(qualifiedName, sourceFile);
+
+            if (existingFile != null && !Objects.equals(existingFile.sourceCode, sourceFile.sourceCode))
+            {
+                throw new IllegalStateException("Duplicate (but different) class: " + qualifiedName);
+            }
+        }
+    }
+
+    static class InMemoryFileManager extends ForwardingJavaFileManager<StandardJavaFileManager>
+    {
+        private final List<InMemoryJavaFileObject> outputFiles = new ArrayList<>();
+
+        InMemoryFileManager(final StandardJavaFileManager fileManager)
+        {
+            super(fileManager);
+        }
+
+        @Override
+        public JavaFileObject getJavaFileForOutput(
+            final Location location,
+            final String className,
+            final JavaFileObject.Kind kind,
+            final FileObject sibling)
+        {
+            final InMemoryJavaFileObject outputFile = new InMemoryJavaFileObject(className, kind);
+            outputFiles.add(outputFile);
+            return outputFile;
+        }
+
+        public Collection<InMemoryJavaFileObject> outputFiles()
+        {
+            return outputFiles;
+        }
+    }
+
+    static class InMemoryJavaFileObject extends SimpleJavaFileObject
+    {
+        private final String sourceCode;
+        private final ByteArrayOutputStream outputStream;
+
+        InMemoryJavaFileObject(final String className, final String sourceCode)
+        {
+            super(URI.create("string:///" + className.replace('.', '/') + Kind.SOURCE.extension), Kind.SOURCE);
+            this.sourceCode = sourceCode;
+            this.outputStream = new ByteArrayOutputStream();
+        }
+
+        InMemoryJavaFileObject(final String className, final Kind kind)
+        {
+            super(URI.create("mem:///" + className.replace('.', '/') + kind.extension), kind);
+            this.sourceCode = null;
+            this.outputStream = new ByteArrayOutputStream();
+        }
+
+        @Override
+        public CharSequence getCharContent(final boolean ignoreEncodingErrors)
+        {
+            return sourceCode;
+        }
+
+        @Override
+        public ByteArrayOutputStream openOutputStream()
+        {
+            return outputStream;
+        }
+
+        public byte[] getClassBytes()
+        {
+            return outputStream.toByteArray();
+        }
+    }
+
+    static class GeneratedCodeLoader extends URLClassLoader
+    {
+        GeneratedCodeLoader(final ClassLoader parent)
+        {
+            super(new URL[0], parent);
+        }
+
+        void defineClasses(final InMemoryFileManager fileManager)
+        {
+            fileManager.outputFiles().forEach(file ->
+            {
+                final byte[] classBytes = file.getClassBytes();
+                super.defineClass(file.getName(), classBytes, 0, classBytes.length);
+            });
+        }
+    }
+}