diff --git a/code/logic/CMakeLists.txt b/code/logic/CMakeLists.txt index 14fbbef..89620bf 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/fossil/io/framework.h b/code/logic/fossil/io/framework.h index f0b0efd..8492f42 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 "network.h" #include "output.h" diff --git a/code/logic/fossil/io/serialize.h b/code/logic/fossil/io/serialize.h new file mode 100644 index 0000000..79ea2ef --- /dev/null +++ b/code/logic/fossil/io/serialize.h @@ -0,0 +1,688 @@ +/* + * ----------------------------------------------------------------------------- + * 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_i8(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_i16(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_i32(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_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 + * + * 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_f32(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_f64(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_cstr(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_i8(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_i16(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_i32(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_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 + * + * 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_f32(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_f64(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_cstr(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_i8(int8_t value) { + return fossil_io_serialize_i8(&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_i16(int16_t value) { + return fossil_io_serialize_i16(&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_i32(int32_t value) { + return fossil_io_serialize_i32(&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_i64(int64_t value) { + 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. + * + * @param value The float value to serialize + * @return 0 on success, non-zero on failure + */ + int serialize_f32(float value) { + return fossil_io_serialize_f32(&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_f64(double value) { + return fossil_io_serialize_f64(&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_cstr(const char *str) { + return fossil_io_serialize_cstr(&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_i8(size_t *offset, int8_t *value) { + return fossil_io_deserialize_i8(&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_i16(size_t *offset, int16_t *value) { + return fossil_io_deserialize_i16(&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_i32(size_t *offset, int32_t *value) { + return fossil_io_deserialize_i32(&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_i64(size_t *offset, int64_t *value) { + 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. + * + * @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_f32(size_t *offset, float *value) { + return fossil_io_deserialize_f32(&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_f64(size_t *offset, double *value) { + return fossil_io_deserialize_f64(&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_cstr(size_t *offset, char *out, size_t max_len) { + return fossil_io_deserialize_cstr(&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); + } + + private: + fossil_io_serialize_buffer_t buffer; + }; + + } + +} + +#endif + +#endif /* FOSSIL_IO_FRAMEWORK_H */ diff --git a/code/logic/meson.build b/code/logic/meson.build index 1a99b92..94bf05d 100644 --- a/code/logic/meson.build +++ b/code/logic/meson.build @@ -9,7 +9,7 @@ else endif fossil_io_lib = library('fossil-io', - files('parser.c', 'input.c', 'output.c', 'error.c', 'soap.c', 'stream.c', 'keyboard.c', 'network.c'), + files('serialize.c', 'parser.c', 'input.c', 'output.c', 'error.c', 'soap.c', 'stream.c', 'keyboard.c', 'network.c'), install: true, dependencies: [cc.find_library('m', required: false), winsock_dep], include_directories: dir) diff --git a/code/logic/serialize.c b/code/logic/serialize.c new file mode 100644 index 0000000..0e5d9a0 --- /dev/null +++ b/code/logic/serialize.c @@ -0,0 +1,338 @@ +/* + * ----------------------------------------------------------------------------- + * 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 +#include + +#ifdef _WIN32 +#include + +#else +#include + +#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; + 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_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; + } + buf->buffer[buf->size++] = (uint8_t)value; + return 0; +} + +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; + } + 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; +} + +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; + } + 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; +} + +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; + } + 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; +} + +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; + } + memcpy(buf->buffer + buf->size, &value, sizeof(float)); + buf->size += sizeof(float); + return 0; +} + +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; + } + memcpy(buf->buffer + buf->size, &value, sizeof(double)); + buf->size += sizeof(double); + return 0; +} + +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; + } + 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_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_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)); + *value = fossil_io_ntohs(net_value); + *offset += sizeof(int16_t); + return 0; +} + +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)); + *value = fossil_io_ntohl(net_value); + *offset += sizeof(int32_t); + return 0; +} + +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)); + *value = fossil_io_ntohll(net_value); + *offset += sizeof(int64_t); + 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)); + *offset += sizeof(float); + return 0; +} + +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_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); + *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 + fseek(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; +} diff --git a/code/tests/cases/test_serialize.c b/code/tests/cases/test_serialize.c new file mode 100644 index 0000000..2f71a46 --- /dev/null +++ b/code/tests/cases/test_serialize.c @@ -0,0 +1,327 @@ +/* + * ----------------------------------------------------------------------------- + * 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_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_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_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_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..b8ee355 --- /dev/null +++ b/code/tests/cases/test_serialize.cpp @@ -0,0 +1,549 @@ +/* + * ----------------------------------------------------------------------------- + * 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_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_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_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_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_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_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_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_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 5a09e0a..9769f47 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', 'network'] + test_cases = ['parser', 'stream', 'soap', 'input', 'error', 'keyboard', 'network', 'serialize'] foreach cases : test_cases test_c += ['cases' / 'test_' + cases + '.c']