diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 351ec80..03588ca 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -41,7 +41,8 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/mo640_v1.aif DESTINATION ${CMAKE_CURR
file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/mo640.aif DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/data/)
# Test executable (all unit tests)
-add_executable(tests_run crc64.cpp spamsum.cpp crc32.c crc32.h flac.cpp lzma.cpp sha256.cpp md5.cpp sha1.cpp open_image.cpp)
+add_executable(tests_run crc64.cpp spamsum.cpp crc32.c crc32.h flac.cpp lzma.cpp sha256.cpp md5.cpp sha1.cpp open_image.cpp
+ create_image.cpp)
# Link libraries
target_link_libraries(tests_run PRIVATE gtest gtest_main aaruformat)
diff --git a/tests/create_image.cpp b/tests/create_image.cpp
new file mode 100644
index 0000000..e1b8c1f
--- /dev/null
+++ b/tests/create_image.cpp
@@ -0,0 +1,136 @@
+/*
+ * This file is part of the Aaru Data Preservation Suite.
+ * Copyright (c) 2019-2025 Natalia Portillo.
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see .
+ */
+
+#include
+#include
+#include
+
+#include "../include/aaruformat.h"
+#include "gtest/gtest.h"
+
+class CreateImageFixture : public testing::Test
+{
+public:
+ CreateImageFixture() = default;
+
+protected:
+ void SetUp() override
+ {
+ // Test data path will be set by CMake
+ }
+
+ void TearDown() override
+ {
+ // Cleanup if needed
+ }
+};
+
+TEST_F(CreateImageFixture, create_image_uncompresed_duplicated)
+{
+ char path[PATH_MAX];
+ char filename[PATH_MAX];
+
+ getcwd(path, PATH_MAX);
+ snprintf(filename, PATH_MAX, "%s/data/random", path);
+
+ // Open random file
+ FILE *f = fopen(filename, "rb");
+ ASSERT_NE(f, nullptr) << "Failed to open random data file";
+
+ uint8_t *buffer = static_cast(malloc(1048576));
+ fread(buffer, 1, 1048576, f);
+ fclose(f);
+
+ // Static fake UTF-16LE hex string saying "gtest" with interlaced zeroes
+ static const uint8_t fake_utf16le_gtest[] = {0x67, 0x00, 0x74, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00};
+
+ constexpr size_t total_sectors = 128 * 1024 * 1024 / 512; // 128 MiB / 512 bytes
+
+ // Create image
+ void *context = aaruf_create("test.aif", 1, 512, total_sectors, 0, 0, "deduplicate=false;compress=false",
+ fake_utf16le_gtest, 10, 0, 0, false);
+
+ // Verify that the file was successfully opened
+ ASSERT_NE(context, nullptr) << "Failed to create test.aif";
+
+ crc64_ctx *ctx = aaruf_crc64_init();
+ uint64_t generated_crc = 0;
+
+ // Write data in sectors of 512 bytes
+ for(size_t sector = 0; sector < total_sectors; ++sector)
+ {
+ const size_t buffer_offset = sector * 512 % 1048576; // Roll back to start when reaching end
+ const int32_t write_result =
+ aaruf_write_sector(context, sector, false, buffer + buffer_offset, SectorStatusDumped, 512);
+ ASSERT_EQ(write_result, AARUF_STATUS_OK) << "Failed to write sector " << sector;
+
+ aaruf_crc64_update(ctx, buffer + buffer_offset, 512);
+ }
+
+ aaruf_crc64_final(ctx, &generated_crc);
+ aaruf_crc64_free(ctx);
+
+ // Close the image
+ int32_t close_result = aaruf_close(context);
+ ASSERT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+ free(buffer);
+
+ // Reopen the image
+ context = aaruf_open("test.aif");
+ ASSERT_NE(context, nullptr) << "Failed to open test.aif";
+
+ // Get image info to verify it's a valid image
+ ImageInfo image_info;
+ const int32_t result = aaruf_get_image_info(context, &image_info);
+
+ ASSERT_EQ(result, AARUF_STATUS_OK) << "Failed to get image info";
+
+ // Basic sanity checks on the image info
+ ASSERT_EQ(image_info.HasPartitions, false) << "Image should not have partitions";
+ ASSERT_EQ(image_info.HasSessions, false) << "Image should not have sessions";
+ ASSERT_EQ(image_info.Sectors, total_sectors) << "Unexpected number of sectors";
+ ASSERT_EQ(image_info.SectorSize, 512) << "Unexpected sector size";
+ ASSERT_STREQ(image_info.Version, "2.0") << "Unexpected image version";
+ ASSERT_STREQ(image_info.Application, "gtest") << "Unexpected application name";
+ ASSERT_STREQ(image_info.ApplicationVersion, "0.0") << "Unexpected application version";
+ ASSERT_EQ(image_info.MediaType, 1) << "Unexpected media type";
+ ASSERT_EQ(image_info.MetadataMediaType, 1) << "Unexpected metadata media type";
+
+ ctx = aaruf_crc64_init();
+ uint64_t crc = 0;
+
+ for(int i = 0; i < total_sectors; i++)
+ {
+ uint8_t sector_buffer[512];
+ uint32_t length = sizeof(sector_buffer);
+
+ const int32_t read_result = aaruf_read_sector(context, i, false, sector_buffer, &length);
+ EXPECT_EQ(read_result, AARUF_STATUS_OK) << "Failed to read sector " << i;
+ EXPECT_EQ(length, 512U) << "Unexpected length for sector " << i;
+ aaruf_crc64_update(ctx, sector_buffer, 512);
+ }
+
+ aaruf_crc64_final(ctx, &crc);
+ aaruf_crc64_free(ctx);
+
+ ASSERT_EQ(crc, generated_crc) << "Unexpected CRC64 for image data";
+
+ // Close the image
+ close_result = aaruf_close(context);
+ EXPECT_EQ(close_result, AARUF_STATUS_OK) << "Failed to close image";
+}