feat: some api additions, update tests, add zero test proj

DexrnZacAttack · DexrnZacAttack · commit 3d100246a27e · 2026-03-27T22:03:59.000-07:00
diff --git a/.clang-tidy b/.clang-tidy
@@ -32,6 +32,7 @@ CheckOptions:
   readability-identifier-naming.GlobalVariablePrefix: g_
   # locals
   readability-identifier-naming.LocalVariableCase: camelBack
+  readability-identifier-naming.VariableCase: camelBack
   # params
   readability-identifier-naming.ParameterCase: camelBack
   # template params
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION VERSION 3.30)
-project(JavaObjectStreams VERSION 1.3.5)
+project(JavaObjectStreams VERSION 1.3.6)
 
 set(CMAKE_CXX_STANDARD 20)
 
@@ -160,6 +160,14 @@ endif ()
 
 unset(JAVAOBJECTSTREAMS_BUILD_TESTS CACHE)
 
+option(JAVAOBJECTSTREAMS_BUILD_JOBJDUMP "Build JavaObjectDump" ON)
+
+if (JAVAOBJECTSTREAMS_BUILD_JOBJDUMP)
+    add_subdirectory(util/JavaObjectDump)
+endif ()
+
+unset(JAVAOBJECTSTREAMS_BUILD_JOBJDUMP CACHE)
+
 option(JAVAOBJECTSTREAMS_DOCS_TARGET "Create documentation target" ON)
 
 if (JAVAOBJECTSTREAMS_DOCS_TARGET STREQUAL "ON")
diff --git a/include/JavaObject/stream/ObjectInputStream.h b/include/JavaObject/stream/ObjectInputStream.h
@@ -12,6 +12,14 @@
 #define JAVAOBJECTSTREAMS_OBJECTINPUTSTREAM_H
 #include "JavaObject/type/object/ObjectTypeCodeParser.h"
 #include "JavaObject/type/object/types/IObject.h"
+#include "JavaObject/type/object/types/StringObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveBooleanObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveByteObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveDoubleObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveFloatObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveIntegerObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveLongObject.h"
+#include "JavaObject/type/primitive/types/PrimitiveShortObject.h"
 
 #include <iostream>
 #include <memory>
@@ -23,7 +31,17 @@ namespace javaobject::stream {
     public:
         explicit ObjectInputStream(std::istream &input);
 
-        std::shared_ptr<type::object::IObject> readObject();
+        std::shared_ptr<type::object::IObject> readObject() const;
+
+        // TODO seemingly these objects are all written into a BlockData section, ugh!
+        std::shared_ptr<type::primitive::types::PrimitiveBooleanObject> readBool() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveByteObject> readByte() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveShortObject> readShort() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveIntegerObject> readInt() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveLongObject> readLong() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveFloatObject> readFloat() const = delete;
+        std::shared_ptr<type::primitive::types::PrimitiveDoubleObject> readDouble() const = delete;
+
 
         ObjectInputStream &operator>>(std::shared_ptr<type::object::IObject> &object);
     private:
diff --git a/include/JavaObject/stream/ObjectOutputStream.h b/include/JavaObject/stream/ObjectOutputStream.h
@@ -10,11 +10,25 @@
  */
 #ifndef JAVAOBJECTSTREAMS_OBJECTOUTPUTSTREAM_H
 #define JAVAOBJECTSTREAMS_OBJECTOUTPUTSTREAM_H
+#include "JavaObject/type/object/types/IObject.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
 
 // TODO
 
 namespace javaobject::stream {
     class ObjectOutputStream {
+        void writeObject(std::shared_ptr<type::object::IObject> obj);
+        void writeBool(bool b);
+        void writeByte(std::int8_t b);
+        void writeShort(std::int16_t s);
+        void writeInt(std::int32_t i);
+        void writeLong(std::int64_t l);
+        void writeFloat(float f);
+        void writeDouble(double d);
+        void writeString(const std::string &s);
     };
 
     using oobjectstream = ObjectOutputStream;
diff --git a/include/JavaObject/type/ITypeCodeParser.h b/include/JavaObject/type/ITypeCodeParser.h
@@ -23,7 +23,8 @@ namespace javaobject::type {
 
         virtual std::shared_ptr<ObjectT> readNext() = 0;
         virtual std::shared_ptr<ObjectT> readUsingParser(const ParserT &parser) = 0;
-        
+        virtual std::shared_ptr<ObjectT> readUsingTypeCode(const TypeCodeT &typecode) = 0;
+
         template <typename T>
         requires std::is_base_of_v<ObjectT, T>
         std::shared_ptr<T> readNextAs() {
diff --git a/include/JavaObject/type/object/ObjectTypeCodeParser.h b/include/JavaObject/type/object/ObjectTypeCodeParser.h
@@ -28,6 +28,7 @@ namespace javaobject::type::object {
 
         std::shared_ptr<object::IObject> readNext() override;
         std::shared_ptr<object::IObject> readUsingParser(const object::parsers::IObjectParser &parser) override;
+        std::shared_ptr<IObject> readUsingTypeCode(const EObjectTypeCode &typecode) override;
     };
 } // namespace javaobject::type
 
diff --git a/include/JavaObject/type/object/types/ClassDataObject.h b/include/JavaObject/type/object/types/ClassDataObject.h
@@ -38,6 +38,8 @@ namespace javaobject::type::object
 
         std::string toString() override;
 
+        std::shared_ptr<primitive::types::IPrimitiveObject> getFieldValue(const std::string &fieldName);
+
         std::unordered_map<std::string, std::shared_ptr<primitive::types::IPrimitiveObject>> values;
     };
 
diff --git a/include/JavaObject/type/object/types/IObject.h b/include/JavaObject/type/object/types/IObject.h
@@ -12,14 +12,34 @@
 #ifndef JAVAOBJECTSTREAMS_IOBJECT_H
 #define JAVAOBJECTSTREAMS_IOBJECT_H
 
+#include <memory>
 #include <string>
+#include <typeinfo>
 
 namespace javaobject::type::object {
     class IObject {
     public:
         virtual ~IObject() = default;
 
         virtual std::string toString();
+
+        template <typename T>
+        requires std::is_base_of_v<IObject, T>
+        constexpr bool instanceOf() {
+            return typeid(*this) == typeid(T);
+        }
+
+        template <typename T>
+        requires std::is_base_of_v<IObject, T>
+        bool instanceOf(std::shared_ptr<T> object) {
+           return typeid(*this) == typeid(*object);
+        }
+
+        template <typename T>
+        requires std::is_base_of_v<IObject, T>
+        T *as() {
+            return dynamic_cast<T *>(this);
+        }
     };
 } // namespace javaobject::type::object
 
diff --git a/include/JavaObject/type/primitive/PrimitiveTypeCodeParser.h b/include/JavaObject/type/primitive/PrimitiveTypeCodeParser.h
@@ -33,6 +33,7 @@ namespace javaobject::type::primitive {
 
         std::shared_ptr<types::IPrimitiveObject> readNext() override;
         std::shared_ptr<types::IPrimitiveObject> readUsingParser(const parsers::IPrimitiveObjectParser &parser) override;
+        std::shared_ptr<types::IPrimitiveObject> readUsingTypeCode(const EPrimitiveTypeCode &typecode) override;
     };
 } // namespace javaobject::type::primitive
 
diff --git a/include/JavaObject/type/primitive/types/IPrimitiveObject.h b/include/JavaObject/type/primitive/types/IPrimitiveObject.h
@@ -31,10 +31,14 @@ namespace javaobject::type::primitive::types {
     struct IPrimitiveTypeObject : IPrimitiveObject {
         explicit IPrimitiveTypeObject(T value) : value(value) {}
 
-        operator T() {
+        T unwrap() {
             return value;
         }
 
+        operator T() {
+            return unwrap();
+        }
+
         T value;
     };
 } // namespace javaobject::type::primitive::types
diff --git a/src/stream/ObjectInputStream.cpp b/src/stream/ObjectInputStream.cpp
@@ -12,21 +12,18 @@
 
 #include "JavaObject/type/object/types/NullObject.h"
 #include "JavaObject/type/primitive/PrimitiveTypeCodeParser.h"
+#include "JavaObject/EPrimitiveTypeCode.h"
 
 namespace javaobject::stream {
     ObjectInputStream::ObjectInputStream(std::istream &input) : m_handleContainer(), m_input(input), m_stream(input) {
         this->m_parsers.objectParser = std::make_shared<type::object::ObjectTypeCodeParser>(input, m_handleContainer, m_parsers);
         this->m_parsers.primitiveParser = std::make_shared<type::primitive::PrimitiveTypeCodeParser>(input, m_handleContainer, m_parsers);
-    }
 
-    std::shared_ptr<type::object::IObject> ObjectInputStream::readObject() {
         if (const uint16_t magic = this->m_stream.readBE<uint16_t>(); magic != 0xACED) {
-            return std::make_shared<type::object::NullObject>();
+            throw std::runtime_error("File magic does not match!");
         }
 
-        int16_t count = this->m_stream.readBE<uint16_t>();
-
-        return this->m_parsers.objectParser->readNext();
+        int16_t version = this->m_stream.readBE<uint16_t>();
     }
 
     ObjectInputStream &ObjectInputStream::operator>>(std::shared_ptr<type::object::IObject> &object) {
diff --git a/src/type/object/ObjectTypeCodeParser.cpp b/src/type/object/ObjectTypeCodeParser.cpp
@@ -40,6 +40,10 @@ namespace javaobject::type::object {
         this->m_parsers[EObjectTypeCode::TC_ARRAY] = std::make_unique<parsers::ArrayObjectParser>();
     }
 
+    std::shared_ptr<IObject> ObjectTypeCodeParser::readUsingTypeCode(const EObjectTypeCode &typecode) {
+        return this->readUsingParser(*this->getParser(typecode));
+    }
+
     std::shared_ptr<object::IObject> ObjectTypeCodeParser::readNext() {
         const EObjectTypeCode tc = static_cast<EObjectTypeCode>(this->m_input.readByte());
 
diff --git a/src/type/object/types/ClassDataObject.cpp b/src/type/object/types/ClassDataObject.cpp
@@ -20,6 +20,15 @@ namespace javaobject::type::object {
     std::string SerializableClassDataObject::toString() {
         return std::format("SerializableClassData(values={})", this->values.size());
     }
+
+    std::shared_ptr<primitive::types::IPrimitiveObject> SerializableClassDataObject::getFieldValue(const std::string &fieldName) {
+        try {
+            return this->values.at(fieldName);
+        } catch (std::out_of_range &ex) {
+            return nullptr;
+        }
+    }
+
     std::string SerializableWriteMethodClassDataObject::toString() {
         return std::format("SerializableWriteMethodClassData(values={}, annotationContents={})", this->values.size(), this->annotation->contents.size());
     }
diff --git a/src/type/primitive/PrimitiveTypeCodeParser.cpp b/src/type/primitive/PrimitiveTypeCodeParser.cpp
@@ -52,4 +52,8 @@ namespace javaobject::type::primitive {
         const parsers::IPrimitiveObjectParser &parser) {
         return parser(*this);
     }
+
+    std::shared_ptr<types::IPrimitiveObject> PrimitiveTypeCodeParser::readUsingTypeCode(const EPrimitiveTypeCode &typecode) {
+        return this->readUsingParser(*this->getParser(typecode));
+    }
 } // namespace javaobject::type::primitive
diff --git a/tests/cpp/CMakeLists.txt b/tests/cpp/CMakeLists.txt
@@ -31,5 +31,9 @@ target_link_libraries(JavaObjectStreams.Tests.CPP PRIVATE JavaObjectStreams tfw)
 
 # ENABLE INDIVIDUAL TESTS HERE
 target_compile_definitions(JavaObjectStreams.Tests.CPP PRIVATE
-        READ_OBJECT_FILE=true
+        READ_OBJECT_FILE=false
+        READ_NULL_OBJECT_FILE=true
+        READ_ARRAY_OBJECT_FILE=true
+        READ_ARRAY_OBJECT_FILE_WITH_EXTRA_DATA=true
+        READ_MINECRAFT_OBJECT_FILE=true
 )
diff --git a/tests/cpp/src/JavaObjectStreamsTests.cpp b/tests/cpp/src/JavaObjectStreamsTests.cpp
@@ -10,12 +10,14 @@
  * for details.
  */
 #include "JavaObject/stream/ObjectInputStream.h"
+#include "JavaObject/type/object/types/ArrayObject.h"
+#include "JavaObject/type/object/types/NullObject.h"
 
 #include <TestFramework/TestFramework.h>
 
 int main() {
     //todo add all tests
-    // tfw::TestFramework::getInstance()->addTest(READ_OBJECT_FILE, "Read input object", [](const tfw::test::util::TestOutputLogger &logger) {
+    tfw::TestFramework::getInstance()->addTest(READ_OBJECT_FILE, "Read input object", [](const tfw::test::util::TestOutputLogger &logger) {
         std::ifstream input("input/JOSTestClass.obj");
         input.exceptions(std::ios::badbit | std::ios::eofbit);
 
@@ -25,9 +27,65 @@ int main() {
 
         javaobject::stream::ObjectInputStream ois(input);
         auto obj = ois.readObject();
-    // });
+    });
 
-    // tfw::TestFramework::getInstance()->run();
+    tfw::TestFramework::getInstance()->addTest(READ_NULL_OBJECT_FILE, "Read null input object", [](const tfw::test::util::TestOutputLogger &logger) {
+        std::ifstream input("input/JOSTestNull.obj");
+        input.exceptions(std::ios::badbit | std::ios::eofbit);
+
+        if (!input.is_open()) {
+            throw std::runtime_error("nah");
+        }
+
+        javaobject::stream::ObjectInputStream ois(input);
+        auto obj = ois.readObject();
+
+        return tfw::test::result::TestResult(obj->instanceOf<javaobject::type::object::NullObject>());
+    });
+
+    tfw::TestFramework::getInstance()->addTest(READ_ARRAY_OBJECT_FILE, "Read array input object", [](const tfw::test::util::TestOutputLogger &logger) {
+        std::ifstream input("input/JOSTestArray.obj");
+        input.exceptions(std::ios::badbit | std::ios::eofbit);
+
+        if (!input.is_open()) {
+            throw std::runtime_error("nah");
+        }
+
+        javaobject::stream::ObjectInputStream ois(input);
+        auto obj = ois.readObject();
+
+        return tfw::test::result::TestResult(obj->instanceOf<javaobject::type::object::types::ArrayObject>());
+    });
+
+    tfw::TestFramework::getInstance()->addTest(READ_ARRAY_OBJECT_FILE_WITH_EXTRA_DATA, "Read array + extra data input object", [](const tfw::test::util::TestOutputLogger &logger) {
+        std::ifstream input("input/JOSTestArrayWithExtraData.obj");
+        input.exceptions(std::ios::badbit | std::ios::eofbit);
+
+        if (!input.is_open()) {
+            throw std::runtime_error("nah");
+        }
+
+        javaobject::stream::ObjectInputStream ois(input);
+        auto dat = ois.readObject();
+        auto array = ois.readObject();
+
+        return tfw::test::result::TestResult(array->instanceOf<javaobject::type::object::types::ArrayObject>());
+    });
+
+    // TODO: Re-serialize read object in WRITE_MINECRAFT_OBJECT_FILE
+    tfw::TestFramework::getInstance()->addTest(READ_MINECRAFT_OBJECT_FILE, "Read Minecraft object", [](const tfw::test::util::TestOutputLogger &logger) {
+        std::ifstream input("input/MinecraftJOSTestClass.obj");
+        input.exceptions(std::ios::badbit | std::ios::eofbit);
+
+        if (!input.is_open()) {
+            throw std::runtime_error("nah");
+        }
+
+        javaobject::stream::ObjectInputStream ois(input);
+        auto obj = ois.readObject();
+    });
+
+    tfw::TestFramework::getInstance()->run();
 
     return 0;
 }
diff --git a/tests/java/modules/Output/src/main/java/me/dexrn/jos/output/OutputTestFile.java b/tests/java/modules/Output/src/main/java/me/dexrn/jos/output/OutputTestFile.java
@@ -14,6 +14,7 @@
 
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.nio.file.Path;
 
@@ -24,9 +25,49 @@ public static void main(String[] args) throws IOException {
 			dir = args[0];
 		}
 		
+		writeClass(dir);
+		writeArray(dir);
+		writeNull(dir);
+		writeCustom(dir);
+	}
+	
+	private static void writeClass(String dir) throws IOException {
 		FileOutputStream fos = new FileOutputStream(Path.of(dir, "JOSTestClass.obj").toFile());
 		ObjectOutputStream oos = new ObjectOutputStream(fos);
-		
+
 		oos.writeObject(new JOSTestClass());
 	}
+	
+	private static void writeArray(String dir) throws IOException {
+		int[] arr = new int[512];
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = i;
+		}
+		
+		FileOutputStream fos = new FileOutputStream(Path.of(dir, "JOSTestArray.obj").toFile());
+		ObjectOutputStream oos = new ObjectOutputStream(fos);
+		
+		oos.writeObject(arr);
+	}
+	
+	private static void writeNull(String dir) throws IOException {
+		FileOutputStream fos = new FileOutputStream(Path.of(dir, "JOSTestNull.obj").toFile());
+		ObjectOutputStream oos = new ObjectOutputStream(fos);
+
+		oos.writeObject(null);
+	}
+	
+	private static void writeCustom(String dir) throws IOException {
+		int[] arr = new int[512];
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = i;
+		}
+
+		FileOutputStream fos = new FileOutputStream(Path.of(dir, "JOSTestArrayWithExtraData.obj").toFile());
+		ObjectOutputStream oos = new ObjectOutputStream(fos);
+
+		oos.writeUTF("Hello, world!");
+		oos.writeInt(0x12345678);
+		oos.writeObject(arr);
+	}
 }
diff --git a/util/JavaObjectDump/CMakeLists.txt b/util/JavaObjectDump/CMakeLists.txt
diff --git a/util/JavaObjectDump/src/main.cpp b/util/JavaObjectDump/src/main.cpp
