From 5f64a6d22f0a566b60da6d9491331658fd70615c Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:04:02 -0600 Subject: [PATCH 01/15] adding entry for serialize source pair --- code/logic/CMakeLists.txt | 1 + code/logic/meson.build | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/code/logic/CMakeLists.txt b/code/logic/CMakeLists.txt index 2d911f5..90ab972 100644 --- a/code/logic/CMakeLists.txt +++ b/code/logic/CMakeLists.txt @@ -8,6 +8,7 @@ file(GLOB HEADER_FILES ${CMAKE_CURRENT_SOURCE_DIR}/fossil/*.h) # List the source files set(TEST_CODE + serialize.c parser.c error.c input.c diff --git a/code/logic/meson.build b/code/logic/meson.build index 8b27dbd..e0d8a00 100644 --- a/code/logic/meson.build +++ b/code/logic/meson.build @@ -2,7 +2,7 @@ dir = include_directories('.') cc = meson.get_compiler('c') fossil_io_lib = library('fossil-io', - files('parser.c', 'input.c', 'output.c', 'error.c', 'soap.c', 'stream.c', 'keyboard.c'), + files('serialize.c', 'parser.c', 'input.c', 'output.c', 'error.c', 'soap.c', 'stream.c', 'keyboard.c'), install: true, dependencies: cc.find_library('m', required : false), include_directories: dir) From d856574b71ed399ae79ee9f7d3371cba143ac4b9 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:04:25 -0600 Subject: [PATCH 02/15] adding source pair for serialize --- code/logic/fossil/io/serialize.h | 508 +++++++++++++++++++++++++++++++ code/logic/serialize.c | 241 +++++++++++++++ 2 files changed, 749 insertions(+) create mode 100644 code/logic/fossil/io/serialize.h create mode 100644 code/logic/serialize.c diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h new file mode 100644 index 0000000..d653d9f --- /dev/null +++ b/code/logic/fossil/io/serialize.h @@ -0,0 +1,508 @@ +/* + * ----------------------------------------------------------------------------- + * Project: Fossil Logic + * + * This file is part of the Fossil Logic project, which aims to develop high- + * performance, cross-platform applications and libraries. The code contained + * herein is subject to the terms and conditions defined in the project license. + * + * Author: Michael Gene Brockus (Dreamer) + * + * Copyright (C) 2024 Fossil Logic. All rights reserved. + * ----------------------------------------------------------------------------- + */ +#ifndef FOSSIL_IO_SERIALIZE_H +#define FOSSIL_IO_SERIALIZE_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + uint8_t *buffer; + size_t size; + size_t capacity; +} fossil_io_serialize_buffer_t; + +/** + * @brief Initialize serialization buffer + * + * This function initializes a serialization buffer with the specified capacity. + * + * @param buf Pointer to the serialization buffer to initialize + * @param capacity The capacity of the buffer + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_create(fossil_io_serialize_buffer_t *buf, size_t capacity); + +/** + * @brief Free serialization buffer + * + * This function frees the resources associated with a serialization buffer. + * + * @param buf Pointer to the serialization buffer to free + */ +void fossil_io_serialize_destroy(fossil_io_serialize_buffer_t *buf); + +/** + * @brief Expand serialization buffer + * + * This function expands the capacity of a serialization buffer by the specified amount. + * + * @param buf Pointer to the serialization buffer to expand + * @param extra The amount to expand the buffer by + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra); + +/** + * @brief Serialize an 8-bit integer + * + * This function serializes an 8-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The 8-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value); + +/** + * @brief Serialize a 16-bit integer + * + * This function serializes a 16-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The 16-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value); + +/** + * @brief Serialize a 32-bit integer + * + * This function serializes a 32-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The 32-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value); + +/** + * @brief Serialize a 64-bit integer + * + * This function serializes a 64-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The 64-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value); + +/** + * @brief Serialize a float + * + * This function serializes a float value into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The float value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value); + +/** + * @brief Serialize a double + * + * This function serializes a double value into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The double value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value); + +/** + * @brief Serialize a string + * + * This function serializes a null-terminated string into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param str The null-terminated string to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_string(fossil_io_serialize_buffer_t *buf, const char *str); + +/** + * @brief Serialize a boolean value + * + * This function serializes a boolean value into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The boolean value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_bool(fossil_io_serialize_buffer_t *buf, int value); + +/** + * @brief Deserialize an 8-bit integer + * + * This function deserializes an 8-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 8-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_int8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value); + +/** + * @brief Deserialize a 16-bit integer + * + * This function deserializes a 16-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 16-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value); + +/** + * @brief Deserialize a 32-bit integer + * + * This function deserializes a 32-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 32-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value); + +/** + * @brief Deserialize a 64-bit integer + * + * This function deserializes a 64-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 64-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value); + +/** + * @brief Deserialize a float + * + * This function deserializes a float value from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the float to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_float(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value); + +/** + * @brief Deserialize a double + * + * This function deserializes a double value from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the double to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value); + +/** + * @brief Deserialize a string + * + * This function deserializes a null-terminated string from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param out Pointer to the buffer to store the deserialized string + * @param max_len The maximum length of the output buffer + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_string(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len); + +/** + * @brief Deserialize a boolean value + * + * This function deserializes a boolean value from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the boolean value to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_bool(fossil_io_serialize_buffer_t *buf, size_t *offset, int *value); + +/** + * @brief Serialize buffer to file + * + * This function serializes a buffer to a file. + * + * @param buf Pointer to the serialization buffer + * @param filename The name of the file to write to + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_to_file(fossil_io_serialize_buffer_t *buf, const char *filename); + +/** + * @brief Deserialize buffer from file + * + * This function deserializes a buffer from a file. + * + * @param buf Pointer to the serialization buffer + * @param filename The name of the file to read from + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_from_file(fossil_io_serialize_buffer_t *buf, const char *filename); + +#ifdef __cplusplus +} + +/** + * Namespace for the Fossil Logic I/O library. + */ +namespace fossil { + + /** + * Namespace for the I/O utilities. + */ + namespace io { + + /** + * Class for handling operations. + */ + class Serialize { + public: + /** + * Constructor to initialize a serialization buffer with the specified capacity. + * + * @param capacity The capacity of the buffer + */ + Serialize(size_t capacity) { + fossil_io_serialize_create(&buffer, capacity); + } + + /** + * Destructor to free the resources associated with a serialization buffer. + */ + ~Serialize() { + fossil_io_serialize_destroy(&buffer); + } + + /** + * Expands the capacity of a serialization buffer by the specified amount. + * + * @param extra The amount to expand the buffer by + * @return 0 on success, non-zero on failure + */ + int expand(size_t extra) { + return fossil_io_serialize_expand(&buffer, extra); + } + + /** + * Serializes an 8-bit integer into the buffer. + * + * @param value The 8-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_int8(int8_t value) { + return fossil_io_serialize_int8(&buffer, value); + } + + /** + * Serializes a 16-bit integer into the buffer. + * + * @param value The 16-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_int16(int16_t value) { + return fossil_io_serialize_int16(&buffer, value); + } + + /** + * Serializes a 32-bit integer into the buffer. + * + * @param value The 32-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_int32(int32_t value) { + return fossil_io_serialize_int32(&buffer, value); + } + + /** + * Serializes a 64-bit integer into the buffer. + * + * @param value The 64-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_int64(int64_t value) { + return fossil_io_serialize_int64(&buffer, value); + } + + /** + * Serializes a float value into the buffer. + * + * @param value The float value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_float(float value) { + return fossil_io_serialize_float(&buffer, value); + } + + /** + * Serializes a double value into the buffer. + * + * @param value The double value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_double(double value) { + return fossil_io_serialize_double(&buffer, value); + } + + /** + * Serializes a null-terminated string into the buffer. + * + * @param str The null-terminated string to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_string(const char *str) { + return fossil_io_serialize_string(&buffer, str); + } + + /** + * Serializes a boolean value into the buffer. + * + * @param value The boolean value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_bool(int value) { + return fossil_io_serialize_bool(&buffer, value); + } + + /** + * Deserializes an 8-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 8-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_int8(size_t *offset, int8_t *value) { + return fossil_io_deserialize_int8(&buffer, offset, value); + } + + /** + * Deserializes a 16-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 16-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_int16(size_t *offset, int16_t *value) { + return fossil_io_deserialize_int16(&buffer, offset, value); + } + + /** + * Deserializes a 32-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 32-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_int32(size_t *offset, int32_t *value) { + return fossil_io_deserialize_int32(&buffer, offset, value); + } + + /** + * Deserializes a 64-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the 64-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_int64(size_t *offset, int64_t *value) { + return fossil_io_deserialize_int64(&buffer, offset, value); + } + + /** + * Deserializes a float value from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the float to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_float(size_t *offset, float *value) { + return fossil_io_deserialize_float(&buffer, offset, value); + } + + /** + * Deserializes a double value from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the double to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_double(size_t *offset, double *value) { + return fossil_io_deserialize_double(&buffer, offset, value); + } + + /** + * Deserializes a null-terminated string from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param out Pointer to the buffer to store the deserialized string + * @param max_len The maximum length of the output buffer + * @return 0 on success, non-zero on failure + */ + int deserialize_string(size_t *offset, char *out, size_t max_len) { + return fossil_io_deserialize_string(&buffer, offset, out, max_len); + } + + /** + * Deserializes a boolean value from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the boolean value to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_bool(size_t *offset, int *value) { + return fossil_io_deserialize_bool(&buffer, offset, value); + } + + /** + * Serializes a buffer to a file. + * + * @param filename The name of the file to write to + * @return 0 on success, non-zero on failure + */ + int serialize_to_file(const char *filename) { + return fossil_io_serialize_to_file(&buffer, filename); + } + + /** + * Deserializes a buffer from a file. + * + * @param filename The name of the file to read from + * @return 0 on success, non-zero on failure + */ + int deserialize_from_file(const char *filename) { + return fossil_io_deserialize_from_file(&buffer, filename); + } + + } + +} + +#endif + +#endif /* FOSSIL_IO_FRAMEWORK_H */ diff --git a/code/logic/serialize.c b/code/logic/serialize.c new file mode 100644 index 0000000..1c05c08 --- /dev/null +++ b/code/logic/serialize.c @@ -0,0 +1,241 @@ +/* + * ----------------------------------------------------------------------------- + * Project: Fossil Logic + * + * This file is part of the Fossil Logic project, which aims to develop high- + * performance, cross-platform applications and libraries. The code contained + * herein is subject to the terms and conditions defined in the project license. + * + * Author: Michael Gene Brockus (Dreamer) + * + * Copyright (C) 2024 Fossil Logic. All rights reserved. + * ----------------------------------------------------------------------------- + */ +#include "fossil/io/serialize.h" +#include +#include + +#ifdef _WIN32 +#include +#define fseeko _fseeki64 // Use Windows-specific fseek for large files + +#else +#include +#include // htonl, ntohl for endian handling + +#endif + +// Initialization and memory management +int fossil_io_serialize_create(fossil_io_serialize_buffer_t *buf, size_t capacity) { + if (!buf) return -1; + buf->buffer = (uint8_t *)malloc(capacity); + if (!buf->buffer) return -1; + buf->size = 0; + buf->capacity = capacity; + return 0; +} + +void fossil_io_serialize_destroy(fossil_io_serialize_buffer_t *buf) { + if (buf && buf->buffer) { + free(buf->buffer); + buf->buffer = NULL; + buf->size = buf->capacity = 0; + } +} + +int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra) { + if (!buf) return -1; + size_t new_capacity = buf->capacity * 2 + extra; + uint8_t *new_buffer = (uint8_t *)realloc(buf->buffer, new_capacity); + if (!new_buffer) return -1; + + buf->buffer = new_buffer; + buf->capacity = new_capacity; + return 0; +} + +int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra) { + if (!buf) return -1; + size_t new_capacity = buf->capacity * 2 + extra; + uint8_t *new_buffer = (uint8_t *)realloc(buf->buffer, new_capacity); + if (!new_buffer) return -1; + + buf->buffer = new_buffer; + buf->capacity = new_capacity; + return 0; +} + +int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value) { + if (buf->size + sizeof(int8_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(int8_t)) != 0) return -1; + } + buf->buffer[buf->size++] = (uint8_t)value; + return 0; +} + +int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value) { + if (buf->size + sizeof(int16_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(int16_t)) != 0) return -1; + } + int16_t net_value = htons(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(int16_t)); + buf->size += sizeof(int16_t); + return 0; +} + +int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value) { + if (buf->size + sizeof(int32_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(int32_t)) != 0) return -1; + } + int32_t net_value = htonl(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(int32_t)); + buf->size += sizeof(int32_t); + return 0; +} + +int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value) { + if (buf->size + sizeof(int64_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(int64_t)) != 0) return -1; + } + int64_t net_value = htonll(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(int64_t)); + buf->size += sizeof(int64_t); + return 0; +} + +int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value) { + if (buf->size + sizeof(float) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(float)) != 0) return -1; + } + memcpy(buf->buffer + buf->size, &value, sizeof(float)); + buf->size += sizeof(float); + return 0; +} + +int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value) { + if (buf->size + sizeof(double) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(double)) != 0) return -1; + } + memcpy(buf->buffer + buf->size, &value, sizeof(double)); + buf->size += sizeof(double); + return 0; +} + +int fossil_io_serialize_string(fossil_io_serialize_buffer_t *buf, const char *str) { + size_t len = strlen(str) + 1; // Include null-terminator + if (buf->size + len > buf->capacity) { + if (fossil_io_serialize_expand(buf, len) != 0) return -1; + } + memcpy(buf->buffer + buf->size, str, len); + buf->size += len; + return 0; +} + +int fossil_io_serialize_bool(fossil_io_serialize_buffer_t *buf, int value) { + if (buf->size + sizeof(int) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(int)) != 0) return -1; + } + buf->buffer[buf->size++] = (uint8_t)value; + return 0; +} + +int fossil_io_deserialize_int8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value) { + if (*offset + sizeof(int8_t) > buf->size) return -1; + *value = buf->buffer[(*offset)++]; + return 0; +} + +int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value) { + if (*offset + sizeof(int16_t) > buf->size) return -1; + int16_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(int16_t)); + *value = ntohs(net_value); + *offset += sizeof(int16_t); + return 0; +} + +int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value) { + if (*offset + sizeof(int32_t) > buf->size) return -1; + int32_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(int32_t)); + *value = ntohl(net_value); + *offset += sizeof(int32_t); + return 0; +} + +int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value) { + if (*offset + sizeof(int64_t) > buf->size) return -1; + int64_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(int64_t)); + *value = ntohll(net_value); + *offset += sizeof(int64_t); + return 0; +} + +int fossil_io_deserialize_float(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value) { + if (*offset + sizeof(float) > buf->size) return -1; + memcpy(value, buf->buffer + *offset, sizeof(float)); + *offset += sizeof(float); + return 0; +} + +int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value) { + if (*offset + sizeof(double) > buf->size) return -1; + memcpy(value, buf->buffer + *offset, sizeof(double)); + *offset += sizeof(double); + return 0; +} + +int fossil_io_deserialize_string(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len) { + size_t len = strnlen((char *)(buf->buffer + *offset), max_len); + if (*offset + len + 1 > buf->size) return -1; + memcpy(out, buf->buffer + *offset, len + 1); + *offset += len + 1; + return 0; +} + +int fossil_io_deserialize_bool(fossil_io_serialize_buffer_t *buf, size_t *offset, int *value) { + if (*offset + 1 > buf->size) return -1; + *value = buf->buffer[(*offset)++]; + return 0; +} + +// File-based serialization functions +int fossil_io_serialize_to_file(fossil_io_serialize_buffer_t *buf, const char *filename) { + FILE *file = fopen(filename, "wb"); + if (!file) return -1; + size_t written = fwrite(buf->buffer, 1, buf->size, file); + if (written != buf->size) { + fclose(file); + return -1; + } + fclose(file); + return 0; +} + +int fossil_io_deserialize_from_file(fossil_io_serialize_buffer_t *buf, const char *filename) { + FILE *file = fopen(filename, "rb"); + if (!file) return -1; + + // Seek to the end of the file to get its size + fseeko(file, 0, SEEK_END); + size_t file_size = ftell(file); + rewind(file); + + if (fossil_io_serialize_create(buf, file_size) != 0) { + fclose(file); + return -1; + } + + // Read the file content into the buffer + size_t read = fread(buf->buffer, 1, file_size, file); + if (read != file_size) { + fossil_io_serialize_destroy(buf); + fclose(file); + return -1; + } + + buf->size = file_size; + fclose(file); + return 0; +} From ab11860b98334864dd0afef92b473f6d1c29e678 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:11:25 -0600 Subject: [PATCH 03/15] remove extra expand --- code/logic/serialize.c | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index 1c05c08..ef2bb02 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -54,17 +54,6 @@ int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra) return 0; } -int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra) { - if (!buf) return -1; - size_t new_capacity = buf->capacity * 2 + extra; - uint8_t *new_buffer = (uint8_t *)realloc(buf->buffer, new_capacity); - if (!new_buffer) return -1; - - buf->buffer = new_buffer; - buf->capacity = new_capacity; - return 0; -} - int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value) { if (buf->size + sizeof(int8_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int8_t)) != 0) return -1; From 985cdf1101ed47edc6db134ae509952f4de4aab4 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:20:24 -0600 Subject: [PATCH 04/15] apply macros --- code/logic/serialize.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index ef2bb02..264efed 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -17,6 +17,7 @@ #ifdef _WIN32 #include +#include // htonl, ntohl for endian handling #define fseeko _fseeki64 // Use Windows-specific fseek for large files #else @@ -86,7 +87,11 @@ int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value) if (buf->size + sizeof(int64_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int64_t)) != 0) return -1; } +#ifdef _WIN32 int64_t net_value = htonll(value); +#else + int64_t net_value = htobe64(value); +#endif memcpy(buf->buffer + buf->size, &net_value, sizeof(int64_t)); buf->size += sizeof(int64_t); return 0; @@ -156,7 +161,11 @@ int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offse if (*offset + sizeof(int64_t) > buf->size) return -1; int64_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int64_t)); +#ifdef _WIN32 *value = ntohll(net_value); +#else + *value = be64toh(net_value); +#endif *offset += sizeof(int64_t); return 0; } @@ -208,7 +217,7 @@ int fossil_io_deserialize_from_file(fossil_io_serialize_buffer_t *buf, const cha // Seek to the end of the file to get its size fseeko(file, 0, SEEK_END); - size_t file_size = ftell(file); + size_t file_size = ftello(file); rewind(file); if (fossil_io_serialize_create(buf, file_size) != 0) { From 03e0b663dc92e07269b5850022bca12d41f906b3 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:23:26 -0600 Subject: [PATCH 05/15] custom endian handling --- code/logic/serialize.c | 60 +++++++++++++++++++++++++++++++----------- 1 file changed, 44 insertions(+), 16 deletions(-) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index 264efed..2c506ef 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -17,15 +17,51 @@ #ifdef _WIN32 #include -#include // htonl, ntohl for endian handling #define fseeko _fseeki64 // Use Windows-specific fseek for large files #else #include -#include // htonl, ntohl for endian handling #endif +// Custom endian handling functions +uint16_t fossil_io_htons(uint16_t hostshort) { + uint16_t result = (hostshort << 8) | (hostshort >> 8); + return result; +} + +uint16_t fossil_io_ntohs(uint16_t netshort) { + return fossil_io_htons(netshort); +} + +uint32_t fossil_io_htonl(uint32_t hostlong) { + uint32_t result = ((hostlong & 0xFF000000) >> 24) | + ((hostlong & 0x00FF0000) >> 8) | + ((hostlong & 0x0000FF00) << 8) | + ((hostlong & 0x000000FF) << 24); + return result; +} + +uint32_t fossil_io_ntohl(uint32_t netlong) { + return fossil_io_htonl(netlong); +} + +uint64_t fossil_io_htonll(uint64_t hostlonglong) { + uint64_t result = ((hostlonglong & 0xFF00000000000000ULL) >> 56) | + ((hostlonglong & 0x00FF000000000000ULL) >> 40) | + ((hostlonglong & 0x0000FF0000000000ULL) >> 24) | + ((hostlonglong & 0x000000FF00000000ULL) >> 8) | + ((hostlonglong & 0x00000000FF000000ULL) << 8) | + ((hostlonglong & 0x0000000000FF0000ULL) << 24) | + ((hostlonglong & 0x000000000000FF00ULL) << 40) | + ((hostlonglong & 0x00000000000000FFULL) << 56); + return result; +} + +uint64_t fossil_io_ntohll(uint64_t netlonglong) { + return fossil_io_htonll(netlonglong); +} + // Initialization and memory management int fossil_io_serialize_create(fossil_io_serialize_buffer_t *buf, size_t capacity) { if (!buf) return -1; @@ -67,7 +103,7 @@ int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value) if (buf->size + sizeof(int16_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int16_t)) != 0) return -1; } - int16_t net_value = htons(value); + int16_t net_value = fossil_io_htons(value); memcpy(buf->buffer + buf->size, &net_value, sizeof(int16_t)); buf->size += sizeof(int16_t); return 0; @@ -77,7 +113,7 @@ int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value) if (buf->size + sizeof(int32_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int32_t)) != 0) return -1; } - int32_t net_value = htonl(value); + int32_t net_value = fossil_io_htonl(value); memcpy(buf->buffer + buf->size, &net_value, sizeof(int32_t)); buf->size += sizeof(int32_t); return 0; @@ -87,11 +123,7 @@ int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value) if (buf->size + sizeof(int64_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int64_t)) != 0) return -1; } -#ifdef _WIN32 - int64_t net_value = htonll(value); -#else - int64_t net_value = htobe64(value); -#endif + int64_t net_value = fossil_io_htonll(value); memcpy(buf->buffer + buf->size, &net_value, sizeof(int64_t)); buf->size += sizeof(int64_t); return 0; @@ -143,7 +175,7 @@ int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offse if (*offset + sizeof(int16_t) > buf->size) return -1; int16_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int16_t)); - *value = ntohs(net_value); + *value = fossil_io_ntohs(net_value); *offset += sizeof(int16_t); return 0; } @@ -152,7 +184,7 @@ int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offse if (*offset + sizeof(int32_t) > buf->size) return -1; int32_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int32_t)); - *value = ntohl(net_value); + *value = fossil_io_ntohl(net_value); *offset += sizeof(int32_t); return 0; } @@ -161,11 +193,7 @@ int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offse if (*offset + sizeof(int64_t) > buf->size) return -1; int64_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int64_t)); -#ifdef _WIN32 - *value = ntohll(net_value); -#else - *value = be64toh(net_value); -#endif + *value = fossil_io_ntohll(net_value); *offset += sizeof(int64_t); return 0; } From 9611b8fe5e9f7dd41ae82038e248b9477a96bdc1 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:28:11 -0600 Subject: [PATCH 06/15] add missing header --- code/logic/serialize.c | 1 + 1 file changed, 1 insertion(+) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index 2c506ef..e5f1483 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -14,6 +14,7 @@ #include "fossil/io/serialize.h" #include #include +#include #ifdef _WIN32 #include From 95d0dc6577b677a067ef03e55e59820a7a3633ad Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:30:57 -0600 Subject: [PATCH 07/15] switch functions --- code/logic/serialize.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index e5f1483..ae5aa74 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -214,8 +214,8 @@ int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offs } int fossil_io_deserialize_string(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len) { - size_t len = strnlen((char *)(buf->buffer + *offset), max_len); - if (*offset + len + 1 > buf->size) return -1; + size_t len = strlen((char *)(buf->buffer + *offset)); + if (len >= max_len || *offset + len + 1 > buf->size) return -1; memcpy(out, buf->buffer + *offset, len + 1); *offset += len + 1; return 0; @@ -245,8 +245,8 @@ int fossil_io_deserialize_from_file(fossil_io_serialize_buffer_t *buf, const cha if (!file) return -1; // Seek to the end of the file to get its size - fseeko(file, 0, SEEK_END); - size_t file_size = ftello(file); + fseek(file, 0, SEEK_END); + size_t file_size = ftell(file); rewind(file); if (fossil_io_serialize_create(buf, file_size) != 0) { From cce3f018ce16e88d06fcd159ac0d50d12af9539c Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:34:03 -0600 Subject: [PATCH 08/15] remove fseekko macro --- code/logic/serialize.c | 1 - 1 file changed, 1 deletion(-) diff --git a/code/logic/serialize.c b/code/logic/serialize.c index ae5aa74..801e886 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -18,7 +18,6 @@ #ifdef _WIN32 #include -#define fseeko _fseeki64 // Use Windows-specific fseek for large files #else #include From db98c3ad26b80d92c253b916c442d4866407c080 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:42:56 -0600 Subject: [PATCH 09/15] rename --- code/logic/fossil/io/serialize.h | 84 ++++++++++++++++---------------- code/logic/serialize.c | 28 +++++------ 2 files changed, 56 insertions(+), 56 deletions(-) diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h index d653d9f..009f9ba 100644 --- a/code/logic/fossil/io/serialize.h +++ b/code/logic/fossil/io/serialize.h @@ -68,7 +68,7 @@ int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra); * @param value The 8-bit integer value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value); +int fossil_io_serialize_i8(fossil_io_serialize_buffer_t *buf, int8_t value); /** * @brief Serialize a 16-bit integer @@ -79,7 +79,7 @@ int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value); * @param value The 16-bit integer value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value); +int fossil_io_serialize_i16(fossil_io_serialize_buffer_t *buf, int16_t value); /** * @brief Serialize a 32-bit integer @@ -90,7 +90,7 @@ int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value); * @param value The 32-bit integer value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value); +int fossil_io_serialize_i32(fossil_io_serialize_buffer_t *buf, int32_t value); /** * @brief Serialize a 64-bit integer @@ -101,7 +101,7 @@ int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value); * @param value The 64-bit integer value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value); +int fossil_io_serialize_i64(fossil_io_serialize_buffer_t *buf, int64_t value); /** * @brief Serialize a float @@ -112,7 +112,7 @@ int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value); * @param value The float value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value); +int fossil_io_serialize_f32(fossil_io_serialize_buffer_t *buf, float value); /** * @brief Serialize a double @@ -123,7 +123,7 @@ int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value); * @param value The double value to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value); +int fossil_io_serialize_f64(fossil_io_serialize_buffer_t *buf, double value); /** * @brief Serialize a string @@ -134,7 +134,7 @@ int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value); * @param str The null-terminated string to serialize * @return 0 on success, non-zero on failure */ -int fossil_io_serialize_string(fossil_io_serialize_buffer_t *buf, const char *str); +int fossil_io_serialize_cstr(fossil_io_serialize_buffer_t *buf, const char *str); /** * @brief Serialize a boolean value @@ -157,7 +157,7 @@ int fossil_io_serialize_bool(fossil_io_serialize_buffer_t *buf, int value); * @param value Pointer to the 8-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_int8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value); +int fossil_io_deserialize_i8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value); /** * @brief Deserialize a 16-bit integer @@ -169,7 +169,7 @@ int fossil_io_deserialize_int8(fossil_io_serialize_buffer_t *buf, size_t *offset * @param value Pointer to the 16-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value); +int fossil_io_deserialize_i16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value); /** * @brief Deserialize a 32-bit integer @@ -181,7 +181,7 @@ int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offse * @param value Pointer to the 32-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value); +int fossil_io_deserialize_i32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value); /** * @brief Deserialize a 64-bit integer @@ -193,7 +193,7 @@ int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offse * @param value Pointer to the 64-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value); +int fossil_io_deserialize_i64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value); /** * @brief Deserialize a float @@ -205,7 +205,7 @@ int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offse * @param value Pointer to the float to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_float(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value); +int fossil_io_deserialize_f32(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value); /** * @brief Deserialize a double @@ -217,7 +217,7 @@ int fossil_io_deserialize_float(fossil_io_serialize_buffer_t *buf, size_t *offse * @param value Pointer to the double to store the deserialized value * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value); +int fossil_io_deserialize_f64(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value); /** * @brief Deserialize a string @@ -230,7 +230,7 @@ int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offs * @param max_len The maximum length of the output buffer * @return 0 on success, non-zero on failure */ -int fossil_io_deserialize_string(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len); +int fossil_io_deserialize_cstr(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len); /** * @brief Deserialize a boolean value @@ -316,8 +316,8 @@ namespace fossil { * @param value The 8-bit integer value to serialize * @return 0 on success, non-zero on failure */ - int serialize_int8(int8_t value) { - return fossil_io_serialize_int8(&buffer, value); + int serialize_i8(int8_t value) { + return fossil_io_serialize_i8(&buffer, value); } /** @@ -326,8 +326,8 @@ namespace fossil { * @param value The 16-bit integer value to serialize * @return 0 on success, non-zero on failure */ - int serialize_int16(int16_t value) { - return fossil_io_serialize_int16(&buffer, value); + int serialize_i16(int16_t value) { + return fossil_io_serialize_i16(&buffer, value); } /** @@ -336,8 +336,8 @@ namespace fossil { * @param value The 32-bit integer value to serialize * @return 0 on success, non-zero on failure */ - int serialize_int32(int32_t value) { - return fossil_io_serialize_int32(&buffer, value); + int serialize_i32(int32_t value) { + return fossil_io_serialize_i32(&buffer, value); } /** @@ -346,8 +346,8 @@ namespace fossil { * @param value The 64-bit integer value to serialize * @return 0 on success, non-zero on failure */ - int serialize_int64(int64_t value) { - return fossil_io_serialize_int64(&buffer, value); + int serialize_i64(int64_t value) { + return fossil_io_serialize_i64(&buffer, value); } /** @@ -356,8 +356,8 @@ namespace fossil { * @param value The float value to serialize * @return 0 on success, non-zero on failure */ - int serialize_float(float value) { - return fossil_io_serialize_float(&buffer, value); + int serialize_f32(float value) { + return fossil_io_serialize_f32(&buffer, value); } /** @@ -366,8 +366,8 @@ namespace fossil { * @param value The double value to serialize * @return 0 on success, non-zero on failure */ - int serialize_double(double value) { - return fossil_io_serialize_double(&buffer, value); + int serialize_f64(double value) { + return fossil_io_serialize_f64(&buffer, value); } /** @@ -376,8 +376,8 @@ namespace fossil { * @param str The null-terminated string to serialize * @return 0 on success, non-zero on failure */ - int serialize_string(const char *str) { - return fossil_io_serialize_string(&buffer, str); + int serialize_cstr(const char *str) { + return fossil_io_serialize_cstr(&buffer, str); } /** @@ -397,8 +397,8 @@ namespace fossil { * @param value Pointer to the 8-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_int8(size_t *offset, int8_t *value) { - return fossil_io_deserialize_int8(&buffer, offset, value); + int deserialize_i8(size_t *offset, int8_t *value) { + return fossil_io_deserialize_i8(&buffer, offset, value); } /** @@ -408,8 +408,8 @@ namespace fossil { * @param value Pointer to the 16-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_int16(size_t *offset, int16_t *value) { - return fossil_io_deserialize_int16(&buffer, offset, value); + int deserialize_i16(size_t *offset, int16_t *value) { + return fossil_io_deserialize_i16(&buffer, offset, value); } /** @@ -419,8 +419,8 @@ namespace fossil { * @param value Pointer to the 32-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_int32(size_t *offset, int32_t *value) { - return fossil_io_deserialize_int32(&buffer, offset, value); + int deserialize_i32(size_t *offset, int32_t *value) { + return fossil_io_deserialize_i32(&buffer, offset, value); } /** @@ -430,8 +430,8 @@ namespace fossil { * @param value Pointer to the 64-bit integer to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_int64(size_t *offset, int64_t *value) { - return fossil_io_deserialize_int64(&buffer, offset, value); + int deserialize_i64(size_t *offset, int64_t *value) { + return fossil_io_deserialize_i64(&buffer, offset, value); } /** @@ -441,8 +441,8 @@ namespace fossil { * @param value Pointer to the float to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_float(size_t *offset, float *value) { - return fossil_io_deserialize_float(&buffer, offset, value); + int deserialize_f32(size_t *offset, float *value) { + return fossil_io_deserialize_f32(&buffer, offset, value); } /** @@ -452,8 +452,8 @@ namespace fossil { * @param value Pointer to the double to store the deserialized value * @return 0 on success, non-zero on failure */ - int deserialize_double(size_t *offset, double *value) { - return fossil_io_deserialize_double(&buffer, offset, value); + int deserialize_f64(size_t *offset, double *value) { + return fossil_io_deserialize_f64(&buffer, offset, value); } /** @@ -464,8 +464,8 @@ namespace fossil { * @param max_len The maximum length of the output buffer * @return 0 on success, non-zero on failure */ - int deserialize_string(size_t *offset, char *out, size_t max_len) { - return fossil_io_deserialize_string(&buffer, offset, out, max_len); + int deserialize_cstr(size_t *offset, char *out, size_t max_len) { + return fossil_io_deserialize_cstr(&buffer, offset, out, max_len); } /** diff --git a/code/logic/serialize.c b/code/logic/serialize.c index 801e886..2468673 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -91,7 +91,7 @@ int fossil_io_serialize_expand(fossil_io_serialize_buffer_t *buf, size_t extra) return 0; } -int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value) { +int fossil_io_serialize_i8(fossil_io_serialize_buffer_t *buf, int8_t value) { if (buf->size + sizeof(int8_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int8_t)) != 0) return -1; } @@ -99,7 +99,7 @@ int fossil_io_serialize_int8(fossil_io_serialize_buffer_t *buf, int8_t value) { return 0; } -int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value) { +int fossil_io_serialize_i16(fossil_io_serialize_buffer_t *buf, int16_t value) { if (buf->size + sizeof(int16_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int16_t)) != 0) return -1; } @@ -109,7 +109,7 @@ int fossil_io_serialize_int16(fossil_io_serialize_buffer_t *buf, int16_t value) return 0; } -int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value) { +int fossil_io_serialize_i32(fossil_io_serialize_buffer_t *buf, int32_t value) { if (buf->size + sizeof(int32_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int32_t)) != 0) return -1; } @@ -119,7 +119,7 @@ int fossil_io_serialize_int32(fossil_io_serialize_buffer_t *buf, int32_t value) return 0; } -int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value) { +int fossil_io_serialize_i64(fossil_io_serialize_buffer_t *buf, int64_t value) { if (buf->size + sizeof(int64_t) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(int64_t)) != 0) return -1; } @@ -129,7 +129,7 @@ int fossil_io_serialize_int64(fossil_io_serialize_buffer_t *buf, int64_t value) return 0; } -int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value) { +int fossil_io_serialize_f32(fossil_io_serialize_buffer_t *buf, float value) { if (buf->size + sizeof(float) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(float)) != 0) return -1; } @@ -138,7 +138,7 @@ int fossil_io_serialize_float(fossil_io_serialize_buffer_t *buf, float value) { return 0; } -int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value) { +int fossil_io_serialize_f64(fossil_io_serialize_buffer_t *buf, double value) { if (buf->size + sizeof(double) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(double)) != 0) return -1; } @@ -147,7 +147,7 @@ int fossil_io_serialize_double(fossil_io_serialize_buffer_t *buf, double value) return 0; } -int fossil_io_serialize_string(fossil_io_serialize_buffer_t *buf, const char *str) { +int fossil_io_serialize_cstr(fossil_io_serialize_buffer_t *buf, const char *str) { size_t len = strlen(str) + 1; // Include null-terminator if (buf->size + len > buf->capacity) { if (fossil_io_serialize_expand(buf, len) != 0) return -1; @@ -165,13 +165,13 @@ int fossil_io_serialize_bool(fossil_io_serialize_buffer_t *buf, int value) { return 0; } -int fossil_io_deserialize_int8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value) { +int fossil_io_deserialize_i8(fossil_io_serialize_buffer_t *buf, size_t *offset, int8_t *value) { if (*offset + sizeof(int8_t) > buf->size) return -1; *value = buf->buffer[(*offset)++]; return 0; } -int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value) { +int fossil_io_deserialize_i16(fossil_io_serialize_buffer_t *buf, size_t *offset, int16_t *value) { if (*offset + sizeof(int16_t) > buf->size) return -1; int16_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int16_t)); @@ -180,7 +180,7 @@ int fossil_io_deserialize_int16(fossil_io_serialize_buffer_t *buf, size_t *offse return 0; } -int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value) { +int fossil_io_deserialize_i32(fossil_io_serialize_buffer_t *buf, size_t *offset, int32_t *value) { if (*offset + sizeof(int32_t) > buf->size) return -1; int32_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int32_t)); @@ -189,7 +189,7 @@ int fossil_io_deserialize_int32(fossil_io_serialize_buffer_t *buf, size_t *offse return 0; } -int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value) { +int fossil_io_deserialize_i64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value) { if (*offset + sizeof(int64_t) > buf->size) return -1; int64_t net_value; memcpy(&net_value, buf->buffer + *offset, sizeof(int64_t)); @@ -198,21 +198,21 @@ int fossil_io_deserialize_int64(fossil_io_serialize_buffer_t *buf, size_t *offse return 0; } -int fossil_io_deserialize_float(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value) { +int fossil_io_deserialize_f32(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value) { if (*offset + sizeof(float) > buf->size) return -1; memcpy(value, buf->buffer + *offset, sizeof(float)); *offset += sizeof(float); return 0; } -int fossil_io_deserialize_double(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value) { +int fossil_io_deserialize_f64(fossil_io_serialize_buffer_t *buf, size_t *offset, double *value) { if (*offset + sizeof(double) > buf->size) return -1; memcpy(value, buf->buffer + *offset, sizeof(double)); *offset += sizeof(double); return 0; } -int fossil_io_deserialize_string(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len) { +int fossil_io_deserialize_cstr(fossil_io_serialize_buffer_t *buf, size_t *offset, char *out, size_t max_len) { size_t len = strlen((char *)(buf->buffer + *offset)); if (len >= max_len || *offset + len + 1 > buf->size) return -1; memcpy(out, buf->buffer + *offset, len + 1); From b54081fe779cdfaf61e96fa503f3915024da869d Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:56:46 -0600 Subject: [PATCH 10/15] add uint ser --- code/logic/fossil/io/serialize.h | 92 ++++++++++++++++++++++++++++++++ code/logic/serialize.c | 71 ++++++++++++++++++++++++ 2 files changed, 163 insertions(+) diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h index 009f9ba..5ab4682 100644 --- a/code/logic/fossil/io/serialize.h +++ b/code/logic/fossil/io/serialize.h @@ -103,6 +103,50 @@ int fossil_io_serialize_i32(fossil_io_serialize_buffer_t *buf, int32_t value); */ int fossil_io_serialize_i64(fossil_io_serialize_buffer_t *buf, int64_t value); +/** + * @brief Serialize an unsigned 8-bit integer + * + * This function serializes an unsigned 8-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The unsigned 8-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_u8(fossil_io_serialize_buffer_t *buf, uint8_t value); + +/** + * @brief Serialize an unsigned 16-bit integer + * + * This function serializes an unsigned 16-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The unsigned 16-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_u16(fossil_io_serialize_buffer_t *buf, uint16_t value); + +/** + * @brief Serialize an unsigned 32-bit integer + * + * This function serializes an unsigned 32-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The unsigned 32-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_u32(fossil_io_serialize_buffer_t *buf, uint32_t value); + +/** + * @brief Serialize an unsigned 64-bit integer + * + * This function serializes an unsigned 64-bit integer into the buffer. + * + * @param buf Pointer to the serialization buffer + * @param value The unsigned 64-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ +int fossil_io_serialize_u64(fossil_io_serialize_buffer_t *buf, uint64_t value); + /** * @brief Serialize a float * @@ -195,6 +239,54 @@ int fossil_io_deserialize_i32(fossil_io_serialize_buffer_t *buf, size_t *offset, */ int fossil_io_deserialize_i64(fossil_io_serialize_buffer_t *buf, size_t *offset, int64_t *value); +/** + * @brief Deserialize an unsigned 8-bit integer + * + * This function deserializes an unsigned 8-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 8-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_u8(fossil_io_serialize_buffer_t *buf, size_t *offset, uint8_t *value); + +/** + * @brief Deserialize an unsigned 16-bit integer + * + * This function deserializes an unsigned 16-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 16-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_u16(fossil_io_serialize_buffer_t *buf, size_t *offset, uint16_t *value); + +/** + * @brief Deserialize an unsigned 32-bit integer + * + * This function deserializes an unsigned 32-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 32-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_u32(fossil_io_serialize_buffer_t *buf, size_t *offset, uint32_t *value); + +/** + * @brief Deserialize an unsigned 64-bit integer + * + * This function deserializes an unsigned 64-bit integer from the buffer. + * + * @param buf Pointer to the serialization buffer + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 64-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ +int fossil_io_deserialize_u64(fossil_io_serialize_buffer_t *buf, size_t *offset, uint64_t *value); + /** * @brief Deserialize a float * diff --git a/code/logic/serialize.c b/code/logic/serialize.c index 2468673..0e5d9a0 100644 --- a/code/logic/serialize.c +++ b/code/logic/serialize.c @@ -129,6 +129,44 @@ int fossil_io_serialize_i64(fossil_io_serialize_buffer_t *buf, int64_t value) { return 0; } +int fossil_io_serialize_u8(fossil_io_serialize_buffer_t *buf, uint8_t value) { + if (buf->size + sizeof(uint8_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(uint8_t)) != 0) return -1; + } + buf->buffer[buf->size++] = value; + return 0; +} + +int fossil_io_serialize_u16(fossil_io_serialize_buffer_t *buf, uint16_t value) { + if (buf->size + sizeof(uint16_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(uint16_t)) != 0) return -1; + } + uint16_t net_value = fossil_io_htons(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(uint16_t)); + buf->size += sizeof(uint16_t); + return 0; +} + +int fossil_io_serialize_u32(fossil_io_serialize_buffer_t *buf, uint32_t value) { + if (buf->size + sizeof(uint32_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(uint32_t)) != 0) return -1; + } + uint32_t net_value = fossil_io_htonl(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(uint32_t)); + buf->size += sizeof(uint32_t); + return 0; +} + +int fossil_io_serialize_u64(fossil_io_serialize_buffer_t *buf, uint64_t value) { + if (buf->size + sizeof(uint64_t) > buf->capacity) { + if (fossil_io_serialize_expand(buf, sizeof(uint64_t)) != 0) return -1; + } + uint64_t net_value = fossil_io_htonll(value); + memcpy(buf->buffer + buf->size, &net_value, sizeof(uint64_t)); + buf->size += sizeof(uint64_t); + return 0; +} + int fossil_io_serialize_f32(fossil_io_serialize_buffer_t *buf, float value) { if (buf->size + sizeof(float) > buf->capacity) { if (fossil_io_serialize_expand(buf, sizeof(float)) != 0) return -1; @@ -198,6 +236,39 @@ int fossil_io_deserialize_i64(fossil_io_serialize_buffer_t *buf, size_t *offset, return 0; } +int fossil_io_deserialize_u8(fossil_io_serialize_buffer_t *buf, size_t *offset, uint8_t *value) { + if (*offset + sizeof(uint8_t) > buf->size) return -1; + *value = buf->buffer[(*offset)++]; + return 0; +} + +int fossil_io_deserialize_u16(fossil_io_serialize_buffer_t *buf, size_t *offset, uint16_t *value) { + if (*offset + sizeof(uint16_t) > buf->size) return -1; + uint16_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(uint16_t)); + *value = fossil_io_ntohs(net_value); + *offset += sizeof(uint16_t); + return 0; +} + +int fossil_io_deserialize_u32(fossil_io_serialize_buffer_t *buf, size_t *offset, uint32_t *value) { + if (*offset + sizeof(uint32_t) > buf->size) return -1; + uint32_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(uint32_t)); + *value = fossil_io_ntohl(net_value); + *offset += sizeof(uint32_t); + return 0; +} + +int fossil_io_deserialize_u64(fossil_io_serialize_buffer_t *buf, size_t *offset, uint64_t *value) { + if (*offset + sizeof(uint64_t) > buf->size) return -1; + uint64_t net_value; + memcpy(&net_value, buf->buffer + *offset, sizeof(uint64_t)); + *value = fossil_io_ntohll(net_value); + *offset += sizeof(uint64_t); + return 0; +} + int fossil_io_deserialize_f32(fossil_io_serialize_buffer_t *buf, size_t *offset, float *value) { if (*offset + sizeof(float) > buf->size) return -1; memcpy(value, buf->buffer + *offset, sizeof(float)); From 7d8e4c8b9ff6c22a1fab469c9a9f2c993f17af24 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 11:57:05 -0600 Subject: [PATCH 11/15] link new ser pair --- code/logic/fossil/io/framework.h | 1 + 1 file changed, 1 insertion(+) diff --git a/code/logic/fossil/io/framework.h b/code/logic/fossil/io/framework.h index 02bfc3f..ad6bb97 100644 --- a/code/logic/fossil/io/framework.h +++ b/code/logic/fossil/io/framework.h @@ -15,6 +15,7 @@ #define FOSSIL_IO_FRAMEWORK_H // Include the necessary headers +#include "serialize.h" #include "keyboard.h" #include "output.h" #include "input.h" From 4125f176cfe38cd1437dca2b8ccc124d1e8a666c Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 12:00:11 -0600 Subject: [PATCH 12/15] add new methods to the class --- code/logic/fossil/io/serialize.h | 84 ++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h index 5ab4682..f7c4fd0 100644 --- a/code/logic/fossil/io/serialize.h +++ b/code/logic/fossil/io/serialize.h @@ -442,6 +442,46 @@ namespace fossil { return fossil_io_serialize_i64(&buffer, value); } + /** + * Serializes an unsigned 8-bit integer into the buffer. + * + * @param value The unsigned 8-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_u8(uint8_t value) { + return fossil_io_serialize_u8(&buffer, value); + } + + /** + * Serializes an unsigned 16-bit integer into the buffer. + * + * @param value The unsigned 16-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_u16(uint16_t value) { + return fossil_io_serialize_u16(&buffer, value); + } + + /** + * Serializes an unsigned 32-bit integer into the buffer. + * + * @param value The unsigned 32-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_u32(uint32_t value) { + return fossil_io_serialize_u32(&buffer, value); + } + + /** + * Serializes an unsigned 64-bit integer into the buffer. + * + * @param value The unsigned 64-bit integer value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_u64(uint64_t value) { + return fossil_io_serialize_u64(&buffer, value); + } + /** * Serializes a float value into the buffer. * @@ -526,6 +566,50 @@ namespace fossil { return fossil_io_deserialize_i64(&buffer, offset, value); } + /** + * Deserializes an unsigned 8-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 8-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_u8(size_t *offset, uint8_t *value) { + return fossil_io_deserialize_u8(&buffer, offset, value); + } + + /** + * Deserializes an unsigned 16-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 16-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_u16(size_t *offset, uint16_t *value) { + return fossil_io_deserialize_u16(&buffer, offset, value); + } + + /** + * Deserializes an unsigned 32-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 32-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_u32(size_t *offset, uint32_t *value) { + return fossil_io_deserialize_u32(&buffer, offset, value); + } + + /** + * Deserializes an unsigned 64-bit integer from the buffer. + * + * @param offset Pointer to the offset within the buffer to start deserialization + * @param value Pointer to the unsigned 64-bit integer to store the deserialized value + * @return 0 on success, non-zero on failure + */ + int deserialize_u64(size_t *offset, uint64_t *value) { + return fossil_io_deserialize_u64(&buffer, offset, value); + } + /** * Deserializes a float value from the buffer. * From b8f10b491b815837fa6e5dafd2e02d05dd56a68a Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 12:41:46 -0600 Subject: [PATCH 13/15] add tests --- code/tests/cases/test_serialize.c | 372 ++++++++++++++++ code/tests/cases/test_serialize.cpp | 629 ++++++++++++++++++++++++++++ code/tests/meson.build | 2 +- 3 files changed, 1002 insertions(+), 1 deletion(-) create mode 100644 code/tests/cases/test_serialize.c create mode 100644 code/tests/cases/test_serialize.cpp diff --git a/code/tests/cases/test_serialize.c b/code/tests/cases/test_serialize.c new file mode 100644 index 0000000..3161459 --- /dev/null +++ b/code/tests/cases/test_serialize.c @@ -0,0 +1,372 @@ +/* + * ----------------------------------------------------------------------------- + * Project: Fossil Logic + * + * This file is part of the Fossil Logic project, which aims to develop high- + * performance, cross-platform applications and libraries. The code contained + * herein is subject to the terms and conditions defined in the project license. + * + * Author: Michael Gene Brockus (Dreamer) + * + * Copyright (C) 2024 Fossil Logic. All rights reserved. + * ----------------------------------------------------------------------------- + */ +#include + +#include "fossil/io/framework.h" + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Utilites +// * * * * * * * * * * * * * * * * * * * * * * * * +// Setup steps for things like test fixtures and +// mock objects are set here. +// * * * * * * * * * * * * * * * * * * * * * * * * + +// Define the test suite and add test cases +FOSSIL_TEST_SUITE(c_serialize_suite); + +// Setup function for the test suite +FOSSIL_SETUP(c_serialize_suite) { + // Setup code here +} + +// Teardown function for the test suite +FOSSIL_TEARDOWN(c_serialize_suite) { + // Teardown code here +} + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Cases +// * * * * * * * * * * * * * * * * * * * * * * * * +// The test cases below are provided as samples, inspired +// by the Meson build system's approach of using test cases +// as samples for library usage. +// * * * * * * * * * * * * * * * * * * * * * * * * + +FOSSIL_TEST_CASE(c_test_io_serialize_create) { + fossil_io_serialize_buffer_t buf; + int result = fossil_io_serialize_create(&buf, 1024); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_destroy) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_destroy(&buf); + // No explicit assertion needed, just ensure no crash +} + +FOSSIL_TEST_CASE(c_test_io_serialize_expand) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_expand(&buf, 512); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_i8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i8(&buf, 127); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_i16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i16(&buf, 32767); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_i32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i32(&buf, 2147483647); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_i64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i64(&buf, 9223372036854775807LL); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_u8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u8(&buf, 255); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_u16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u16(&buf, 65535); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_u32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u32(&buf, 4294967295U); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_u64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u64(&buf, 18446744073709551615ULL); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_f32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_f32(&buf, 3.14f); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_f64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_f64(&buf, 3.141592653589793); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_cstr) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_cstr(&buf, "test string"); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_bool) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_bool(&buf, 1); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_i8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i8(&buf, 127); + size_t offset = 0; + int8_t value; + int result = fossil_io_deserialize_i8(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(127, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_i16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i16(&buf, 32767); + size_t offset = 0; + int16_t value; + int result = fossil_io_deserialize_i16(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(32767, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_i32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i32(&buf, 2147483647); + size_t offset = 0; + int32_t value; + int result = fossil_io_deserialize_i32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(2147483647, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_i64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i64(&buf, 9223372036854775807LL); + size_t offset = 0; + int64_t value; + int result = fossil_io_deserialize_i64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(9223372036854775807LL, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_u8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u8(&buf, 255); + size_t offset = 0; + uint8_t value; + int result = fossil_io_deserialize_u8(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(255, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_u16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u16(&buf, 65535); + size_t offset = 0; + uint16_t value; + int result = fossil_io_deserialize_u16(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(65535, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_u32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u32(&buf, 4294967295U); + size_t offset = 0; + uint32_t value; + int result = fossil_io_deserialize_u32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(4294967295U, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_u64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u64(&buf, 18446744073709551615ULL); + size_t offset = 0; + uint64_t value; + int result = fossil_io_deserialize_u64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(18446744073709551615ULL, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_f32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_f32(&buf, 3.14f); + size_t offset = 0; + float value; + int result = fossil_io_deserialize_f32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_FLOAT(3.14f, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_f64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_f64(&buf, 3.141592653589793); + size_t offset = 0; + double value; + int result = fossil_io_deserialize_f64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_cstr) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + size_t offset = 0; + char out[20]; + int result = fossil_io_deserialize_cstr(&buf, &offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_CSTR("test string", out); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_bool) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_bool(&buf, 1); + size_t offset = 0; + int value; + int result = fossil_io_deserialize_bool(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(1, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(c_test_io_serialize_to_file) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + int result = fossil_io_serialize_to_file(&buf, "test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); + remove("test_file.bin"); +} + +FOSSIL_TEST_CASE(c_test_io_deserialize_from_file) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + fossil_io_serialize_to_file(&buf, "test_file.bin"); + fossil_io_serialize_destroy(&buf); + + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_deserialize_from_file(&buf, "test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + size_t offset = 0; + char out[20]; + fossil_io_deserialize_cstr(&buf, &offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_CSTR("test string", out); + fossil_io_serialize_destroy(&buf); + remove("test_file.bin"); +} + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Pool +// * * * * * * * * * * * * * * * * * * * * * * * * + +FOSSIL_TEST_GROUP(c_serialize_tests) { + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_create); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_destroy); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_expand); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_i8); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_i16); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_i32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_i64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u8); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u16); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_f32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_f64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_cstr); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_bool); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i8); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i16); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u8); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u16); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_f32); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_f64); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_cstr); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_bool); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_to_file); + FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_from_file); + + FOSSIL_TEST_REGISTER(c_serialize_suite); +} diff --git a/code/tests/cases/test_serialize.cpp b/code/tests/cases/test_serialize.cpp new file mode 100644 index 0000000..f6a889d --- /dev/null +++ b/code/tests/cases/test_serialize.cpp @@ -0,0 +1,629 @@ +/* + * ----------------------------------------------------------------------------- + * Project: Fossil Logic + * + * This file is part of the Fossil Logic project, which aims to develop high- + * performance, cross-platform applications and libraries. The code contained + * herein is subject to the terms and conditions defined in the project license. + * + * Author: Michael Gene Brockus (Dreamer) + * + * Copyright (C) 2024 Fossil Logic. All rights reserved. + * ----------------------------------------------------------------------------- + */ +#include + +#include "fossil/io/framework.h" + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Utilites +// * * * * * * * * * * * * * * * * * * * * * * * * +// Setup steps for things like test fixtures and +// mock objects are set here. +// * * * * * * * * * * * * * * * * * * * * * * * * + +// Define the test suite and add test cases +FOSSIL_TEST_SUITE(cpp_serialize_suite); + +// Setup function for the test suite +FOSSIL_SETUP(cpp_serialize_suite) { + // Setup code here +} + +// Teardown function for the test suite +FOSSIL_TEARDOWN(cpp_serialize_suite) { + // Teardown code here +} + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Cases +// * * * * * * * * * * * * * * * * * * * * * * * * +// The test cases below are provided as samples, inspired +// by the Meson build system's approach of using test cases +// as samples for library usage. +// * * * * * * * * * * * * * * * * * * * * * * * * + +FOSSIL_TEST_CASE(cpp_test_io_serialize_create) { + fossil_io_serialize_buffer_t buf; + int result = fossil_io_serialize_create(&buf, 1024); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_destroy) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_destroy(&buf); + // No explicit assertion needed, just ensure no crash +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_expand) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_expand(&buf, 512); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_i8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i8(&buf, 127); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_i16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i16(&buf, 32767); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_i32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i32(&buf, 2147483647); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_i64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_i64(&buf, 9223372036854775807LL); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_u8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u8(&buf, 255); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_u16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u16(&buf, 65535); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_u32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u32(&buf, 4294967295U); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_u64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_u64(&buf, 18446744073709551615ULL); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_f32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_f32(&buf, 3.14f); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_f64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_f64(&buf, 3.141592653589793); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_cstr) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_cstr(&buf, "test string"); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_bool) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_serialize_bool(&buf, 1); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_i8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i8(&buf, 127); + size_t offset = 0; + int8_t value; + int result = fossil_io_deserialize_i8(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(127, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_i16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i16(&buf, 32767); + size_t offset = 0; + int16_t value; + int result = fossil_io_deserialize_i16(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(32767, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_i32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i32(&buf, 2147483647); + size_t offset = 0; + int32_t value; + int result = fossil_io_deserialize_i32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(2147483647, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_i64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_i64(&buf, 9223372036854775807LL); + size_t offset = 0; + int64_t value; + int result = fossil_io_deserialize_i64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(9223372036854775807LL, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_u8) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u8(&buf, 255); + size_t offset = 0; + uint8_t value; + int result = fossil_io_deserialize_u8(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(255, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_u16) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u16(&buf, 65535); + size_t offset = 0; + uint16_t value; + int result = fossil_io_deserialize_u16(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(65535, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_u32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u32(&buf, 4294967295U); + size_t offset = 0; + uint32_t value; + int result = fossil_io_deserialize_u32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(4294967295U, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_u64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_u64(&buf, 18446744073709551615ULL); + size_t offset = 0; + uint64_t value; + int result = fossil_io_deserialize_u64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(18446744073709551615ULL, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_f32) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_f32(&buf, 3.14f); + size_t offset = 0; + float value; + int result = fossil_io_deserialize_f32(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_FLOAT(3.14f, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_f64) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_f64(&buf, 3.141592653589793); + size_t offset = 0; + double value; + int result = fossil_io_deserialize_f64(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_cstr) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + size_t offset = 0; + char out[20]; + int result = fossil_io_deserialize_cstr(&buf, &offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_CSTR("test string", out); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_bool) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_bool(&buf, 1); + size_t offset = 0; + int value; + int result = fossil_io_deserialize_bool(&buf, &offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(1, value); + fossil_io_serialize_destroy(&buf); +} + +FOSSIL_TEST_CASE(cpp_test_io_serialize_to_file) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + int result = fossil_io_serialize_to_file(&buf, "test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + fossil_io_serialize_destroy(&buf); + remove("test_file.bin"); +} + +FOSSIL_TEST_CASE(cpp_test_io_deserialize_from_file) { + fossil_io_serialize_buffer_t buf; + fossil_io_serialize_create(&buf, 1024); + fossil_io_serialize_cstr(&buf, "test string"); + fossil_io_serialize_to_file(&buf, "test_file.bin"); + fossil_io_serialize_destroy(&buf); + + fossil_io_serialize_create(&buf, 1024); + int result = fossil_io_deserialize_from_file(&buf, "test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + size_t offset = 0; + char out[20]; + fossil_io_deserialize_cstr(&buf, &offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_CSTR("test string", out); + fossil_io_serialize_destroy(&buf); + remove("test_file.bin"); +} + + +FOSSIL_TEST_CASE(cpp_test_serialize_class_create) { + fossil::io::Serialize serializer(1024); + // No explicit assertion needed, just ensure no crash +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_expand) { + fossil::io::Serialize serializer(1024); + int result = serializer.expand(512); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_i8) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_i8(127); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_i16) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_i16(32767); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_i32) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_i32(2147483647); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_i64) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_i64(9223372036854775807LL); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_u8) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_u8(255); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_u16) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_u16(65535); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_u32) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_u32(4294967295U); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_u64) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_u64(18446744073709551615ULL); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_f32) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_f32(3.14f); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_f64) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_f64(3.141592653589793); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_cstr) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_cstr("test string"); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_bool) { + fossil::io::Serialize serializer(1024); + int result = serializer.serialize_bool(1); + ASSUME_ITS_EQUAL_I32(0, result); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_i8) { + fossil::io::Serialize serializer(1024); + serializer.serialize_i8(127); + size_t offset = 0; + int8_t value; + int result = serializer.deserialize_i8(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(127, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_i16) { + fossil::io::Serialize serializer(1024); + serializer.serialize_i16(32767); + size_t offset = 0; + int16_t value; + int result = serializer.deserialize_i16(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(32767, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_i32) { + fossil::io::Serialize serializer(1024); + serializer.serialize_i32(2147483647); + size_t offset = 0; + int32_t value; + int result = serializer.deserialize_i32(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(2147483647, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_i64) { + fossil::io::Serialize serializer(1024); + serializer.serialize_i64(9223372036854775807LL); + size_t offset = 0; + int64_t value; + int result = serializer.deserialize_i64(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(9223372036854775807LL, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_u8) { + fossil::io::Serialize serializer(1024); + serializer.serialize_u8(255); + size_t offset = 0; + uint8_t value; + int result = serializer.deserialize_u8(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(255, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_u16) { + fossil::io::Serialize serializer(1024); + serializer.serialize_u16(65535); + size_t offset = 0; + uint16_t value; + int result = serializer.deserialize_u16(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(65535, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_u32) { + fossil::io::Serialize serializer(1024); + serializer.serialize_u32(4294967295U); + size_t offset = 0; + uint32_t value; + int result = serializer.deserialize_u32(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(4294967295U, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_u64) { + fossil::io::Serialize serializer(1024); + serializer.serialize_u64(18446744073709551615ULL); + size_t offset = 0; + uint64_t value; + int result = serializer.deserialize_u64(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(18446744073709551615ULL, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_f32) { + fossil::io::Serialize serializer(1024); + serializer.serialize_f32(3.14f); + size_t offset = 0; + float value; + int result = serializer.deserialize_f32(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_FLOAT(3.14f, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_f64) { + fossil::io::Serialize serializer(1024); + serializer.serialize_f64(3.141592653589793); + size_t offset = 0; + double value; + int result = serializer.deserialize_f64(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_cstr) { + fossil::io::Serialize serializer(1024); + serializer.serialize_cstr("test string"); + size_t offset = 0; + char out[20]; + int result = serializer.deserialize_cstr(&offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_CSTR("test string", out); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_bool) { + fossil::io::Serialize serializer(1024); + serializer.serialize_bool(1); + size_t offset = 0; + int value; + int result = serializer.deserialize_bool(&offset, &value); + ASSUME_ITS_EQUAL_I32(0, result); + ASSUME_ITS_EQUAL_I32(1, value); +} + +FOSSIL_TEST_CASE(cpp_test_serialize_class_to_file) { + fossil::io::Serialize serializer(1024); + serializer.serialize_cstr("test string"); + int result = serializer.serialize_to_file("test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + remove("test_file.bin"); +} + +FOSSIL_TEST_CASE(cpp_test_deserialize_class_from_file) { + fossil::io::Serialize serializer(1024); + serializer.serialize_cstr("test string"); + serializer.serialize_to_file("test_file.bin"); + + fossil::io::Serialize deserializer(1024); + int result = deserializer.deserialize_from_file("test_file.bin"); + ASSUME_ITS_EQUAL_I32(0, result); + size_t offset = 0; + char out[20]; + deserializer.deserialize_cstr(&offset, out, sizeof(out)); + ASSUME_ITS_EQUAL_CSTR("test string", out); + remove("test_file.bin"); +} + + +// * * * * * * * * * * * * * * * * * * * * * * * * +// * Fossil Logic Test Pool +// * * * * * * * * * * * * * * * * * * * * * * * * + +FOSSIL_TEST_GROUP(cpp_serialize_tests) { + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_create); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_destroy); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_expand); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_i8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_i16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_i32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_i64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_f32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_f64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_cstr); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_bool); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_i8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_i16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_i32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_i64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_f32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_f64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_cstr); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_bool); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_to_file); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_from_file); + + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_create); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_expand); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_i8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_i16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_i32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_i64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_f32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_f64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_cstr); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_bool); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_i8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_i16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_i32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_i64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u8); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u16); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_f32); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_f64); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_cstr); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_bool); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_to_file); + FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_from_file); + + FOSSIL_TEST_REGISTER(cpp_serialize_suite); +} diff --git a/code/tests/meson.build b/code/tests/meson.build index f201f61..a1e419a 100644 --- a/code/tests/meson.build +++ b/code/tests/meson.build @@ -2,7 +2,7 @@ if get_option('with_test').enabled() run_command(['python3', 'tools' / 'generate-runner.py'], check: true) test_c = ['unit_runner.c'] - test_cases = ['parser', 'stream', 'soap', 'input', 'error', 'keyboard'] + test_cases = ['parser', 'stream', 'soap', 'input', 'error', 'keyboard', 'serialize'] foreach cases : test_cases test_c += ['cases' / 'test_' + cases + '.c'] From 21835bcbe7dc4826b1ec1e527145b90a153e4933 Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 12:43:10 -0600 Subject: [PATCH 14/15] fix --- code/logic/fossil/io/serialize.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h index f7c4fd0..79ea2ef 100644 --- a/code/logic/fossil/io/serialize.h +++ b/code/logic/fossil/io/serialize.h @@ -675,6 +675,10 @@ namespace fossil { return fossil_io_deserialize_from_file(&buffer, filename); } + private: + fossil_io_serialize_buffer_t buffer; + }; + } } From fde53c95ce4d95fb03d1864fabedfcc272c7da3b Mon Sep 17 00:00:00 2001 From: "Michael Gene Brockus (Dreamer)" Date: Sat, 1 Feb 2025 12:48:15 -0600 Subject: [PATCH 15/15] update tests --- code/tests/cases/test_serialize.c | 45 ---------------- code/tests/cases/test_serialize.cpp | 80 ----------------------------- 2 files changed, 125 deletions(-) diff --git a/code/tests/cases/test_serialize.c b/code/tests/cases/test_serialize.c index 3161459..2f71a46 100644 --- a/code/tests/cases/test_serialize.c +++ b/code/tests/cases/test_serialize.c @@ -129,22 +129,6 @@ FOSSIL_TEST_CASE(c_test_io_serialize_u64) { fossil_io_serialize_destroy(&buf); } -FOSSIL_TEST_CASE(c_test_io_serialize_f32) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - int result = fossil_io_serialize_f32(&buf, 3.14f); - ASSUME_ITS_EQUAL_I32(0, result); - fossil_io_serialize_destroy(&buf); -} - -FOSSIL_TEST_CASE(c_test_io_serialize_f64) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - int result = fossil_io_serialize_f64(&buf, 3.141592653589793); - ASSUME_ITS_EQUAL_I32(0, result); - fossil_io_serialize_destroy(&buf); -} - FOSSIL_TEST_CASE(c_test_io_serialize_cstr) { fossil_io_serialize_buffer_t buf; fossil_io_serialize_create(&buf, 1024); @@ -257,29 +241,6 @@ FOSSIL_TEST_CASE(c_test_io_deserialize_u64) { fossil_io_serialize_destroy(&buf); } -FOSSIL_TEST_CASE(c_test_io_deserialize_f32) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - fossil_io_serialize_f32(&buf, 3.14f); - size_t offset = 0; - float value; - int result = fossil_io_deserialize_f32(&buf, &offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_FLOAT(3.14f, value); - fossil_io_serialize_destroy(&buf); -} - -FOSSIL_TEST_CASE(c_test_io_deserialize_f64) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - fossil_io_serialize_f64(&buf, 3.141592653589793); - size_t offset = 0; - double value; - int result = fossil_io_deserialize_f64(&buf, &offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); - fossil_io_serialize_destroy(&buf); -} FOSSIL_TEST_CASE(c_test_io_deserialize_cstr) { fossil_io_serialize_buffer_t buf; @@ -349,10 +310,6 @@ FOSSIL_TEST_GROUP(c_serialize_tests) { FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u16); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u32); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_u64); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_f32); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_f64); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_cstr); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_bool); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i8); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i16); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_i32); @@ -361,8 +318,6 @@ FOSSIL_TEST_GROUP(c_serialize_tests) { FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u16); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u32); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_u64); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_f32); - FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_f64); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_cstr); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_deserialize_bool); FOSSIL_TEST_ADD(c_serialize_suite, c_test_io_serialize_to_file); diff --git a/code/tests/cases/test_serialize.cpp b/code/tests/cases/test_serialize.cpp index f6a889d..b8ee355 100644 --- a/code/tests/cases/test_serialize.cpp +++ b/code/tests/cases/test_serialize.cpp @@ -129,22 +129,6 @@ FOSSIL_TEST_CASE(cpp_test_io_serialize_u64) { fossil_io_serialize_destroy(&buf); } -FOSSIL_TEST_CASE(cpp_test_io_serialize_f32) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - int result = fossil_io_serialize_f32(&buf, 3.14f); - ASSUME_ITS_EQUAL_I32(0, result); - fossil_io_serialize_destroy(&buf); -} - -FOSSIL_TEST_CASE(cpp_test_io_serialize_f64) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - int result = fossil_io_serialize_f64(&buf, 3.141592653589793); - ASSUME_ITS_EQUAL_I32(0, result); - fossil_io_serialize_destroy(&buf); -} - FOSSIL_TEST_CASE(cpp_test_io_serialize_cstr) { fossil_io_serialize_buffer_t buf; fossil_io_serialize_create(&buf, 1024); @@ -257,30 +241,6 @@ FOSSIL_TEST_CASE(cpp_test_io_deserialize_u64) { fossil_io_serialize_destroy(&buf); } -FOSSIL_TEST_CASE(cpp_test_io_deserialize_f32) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - fossil_io_serialize_f32(&buf, 3.14f); - size_t offset = 0; - float value; - int result = fossil_io_deserialize_f32(&buf, &offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_FLOAT(3.14f, value); - fossil_io_serialize_destroy(&buf); -} - -FOSSIL_TEST_CASE(cpp_test_io_deserialize_f64) { - fossil_io_serialize_buffer_t buf; - fossil_io_serialize_create(&buf, 1024); - fossil_io_serialize_f64(&buf, 3.141592653589793); - size_t offset = 0; - double value; - int result = fossil_io_deserialize_f64(&buf, &offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); - fossil_io_serialize_destroy(&buf); -} - FOSSIL_TEST_CASE(cpp_test_io_deserialize_cstr) { fossil_io_serialize_buffer_t buf; fossil_io_serialize_create(&buf, 1024); @@ -393,18 +353,6 @@ FOSSIL_TEST_CASE(cpp_test_serialize_class_u64) { ASSUME_ITS_EQUAL_I32(0, result); } -FOSSIL_TEST_CASE(cpp_test_serialize_class_f32) { - fossil::io::Serialize serializer(1024); - int result = serializer.serialize_f32(3.14f); - ASSUME_ITS_EQUAL_I32(0, result); -} - -FOSSIL_TEST_CASE(cpp_test_serialize_class_f64) { - fossil::io::Serialize serializer(1024); - int result = serializer.serialize_f64(3.141592653589793); - ASSUME_ITS_EQUAL_I32(0, result); -} - FOSSIL_TEST_CASE(cpp_test_serialize_class_cstr) { fossil::io::Serialize serializer(1024); int result = serializer.serialize_cstr("test string"); @@ -497,26 +445,6 @@ FOSSIL_TEST_CASE(cpp_test_deserialize_class_u64) { ASSUME_ITS_EQUAL_I32(18446744073709551615ULL, value); } -FOSSIL_TEST_CASE(cpp_test_deserialize_class_f32) { - fossil::io::Serialize serializer(1024); - serializer.serialize_f32(3.14f); - size_t offset = 0; - float value; - int result = serializer.deserialize_f32(&offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_FLOAT(3.14f, value); -} - -FOSSIL_TEST_CASE(cpp_test_deserialize_class_f64) { - fossil::io::Serialize serializer(1024); - serializer.serialize_f64(3.141592653589793); - size_t offset = 0; - double value; - int result = serializer.deserialize_f64(&offset, &value); - ASSUME_ITS_EQUAL_I32(0, result); - ASSUME_ITS_EQUAL_DOUBLE(3.141592653589793, value); -} - FOSSIL_TEST_CASE(cpp_test_deserialize_class_cstr) { fossil::io::Serialize serializer(1024); serializer.serialize_cstr("test string"); @@ -577,8 +505,6 @@ FOSSIL_TEST_GROUP(cpp_serialize_tests) { FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u16); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u32); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_u64); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_f32); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_f64); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_cstr); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_bool); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_i8); @@ -589,8 +515,6 @@ FOSSIL_TEST_GROUP(cpp_serialize_tests) { FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u16); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u32); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_u64); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_f32); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_f64); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_cstr); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_deserialize_bool); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_io_serialize_to_file); @@ -606,8 +530,6 @@ FOSSIL_TEST_GROUP(cpp_serialize_tests) { FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u16); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u32); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_u64); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_f32); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_f64); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_cstr); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_bool); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_i8); @@ -618,8 +540,6 @@ FOSSIL_TEST_GROUP(cpp_serialize_tests) { FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u16); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u32); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_u64); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_f32); - FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_f64); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_cstr); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_deserialize_class_bool); FOSSIL_TEST_ADD(cpp_serialize_suite, cpp_test_serialize_class_to_file);