/****************************************************************************** * @file test_evidence_dao.c * @brief Tests du DAO des preuves numériques. ******************************************************************************/ #include "dao/evidence_dao.h" #include "database/database.h" #include "database/statement.h" #include "models/evidence_record.h" #include #include #include #include /** * @brief Vérifie le refus d’une connexion absente. */ static void test_evidence_dao_new_null_database(void) { EvidenceDao *evidence_dao = NULL; GError *error = NULL; evidence_dao = evidence_dao_new( NULL, &error ); assert(evidence_dao == NULL); assert(error != NULL); assert( error->domain == EVIDENCE_DAO_ERROR ); assert( error->code == (gint) EVIDENCE_DAO_ERROR_INVALID_ARGUMENT ); assert(error->message != NULL); assert(error->message[0] != '\0'); g_clear_error( &error ); } /** * @brief Environnement temporaire d’un test EvidenceDao. */ typedef struct { char *temporary_directory; char *database_path; Database *database; EvidenceDao *evidence_dao; } TestEvidenceDaoFixture; static TestEvidenceDaoFixture test_evidence_dao_fixture_create(void); static void test_evidence_dao_fixture_clear( TestEvidenceDaoFixture *fixture ); /** * @brief Retourne le nombre de preuves présentes dans la base de test. */ static int64_t test_evidence_dao_count_rows( Database *database ) { DatabaseStatement *statement = NULL; int64_t evidence_count = -1; assert(database != NULL); statement = database_statement_prepare( database, "SELECT COUNT(*) FROM preuves;" ); assert(statement != NULL); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_ROW ); assert( database_statement_column_int64( statement, 0, &evidence_count ) ); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_DONE ); database_statement_finalize( statement ); return evidence_count; } /** * @brief Vérifie le refus d’un identifiant déjà utilisé. */ static void test_evidence_dao_insert_duplicate_identifier(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *first_record = NULL; EvidenceRecord *second_record = NULL; GError *error = NULL; first_record = evidence_record_new( "55555555-5555-4555-8555-555555555555", "capture_1.png", "capture_001.png", "01_Preuves_Originales/Captures_Ecran/capture_001.png", "screenshot", 100, "dddddddddddddddddddddddddddddddd" "dddddddddddddddddddddddddddddddd", "2026-07-18T18:00:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(first_record != NULL); assert(error == NULL); second_record = evidence_record_new( "55555555-5555-4555-8555-555555555555", "capture_2.png", "capture_002.png", "01_Preuves_Originales/Captures_Ecran/capture_002.png", "screenshot", 200, "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "2026-07-18T18:05:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(second_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, first_record, &error ) ); assert(error == NULL); assert( !evidence_dao_insert( fixture.evidence_dao, second_record, &error ) ); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_CONSTRAINT ); assert( strstr( error->message, "identifiant" ) != NULL ); assert( test_evidence_dao_count_rows( fixture.database ) == 1 ); g_clear_error( &error ); evidence_record_free( second_record ); evidence_record_free( first_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le refus d’un chemin relatif déjà utilisé. */ static void test_evidence_dao_insert_duplicate_relative_path(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *first_record = NULL; EvidenceRecord *second_record = NULL; GError *error = NULL; const char *shared_relative_path = "01_Preuves_Originales/Documents/document_commun.pdf"; first_record = evidence_record_new( "66666666-6666-4666-8666-666666666666", "document_1.pdf", "document_commun.pdf", shared_relative_path, "document", 300, "ffffffffffffffffffffffffffffffff" "ffffffffffffffffffffffffffffffff", "2026-07-18T18:10:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(first_record != NULL); assert(error == NULL); second_record = evidence_record_new( "77777777-7777-4777-8777-777777777777", "document_2.pdf", "document_commun.pdf", shared_relative_path, "document", 400, "11111111111111111111111111111111" "11111111111111111111111111111111", "2026-07-18T18:15:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(second_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, first_record, &error ) ); assert(error == NULL); assert( !evidence_dao_insert( fixture.evidence_dao, second_record, &error ) ); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_CONSTRAINT ); assert( strstr( error->message, "chemin relatif" ) != NULL ); assert( test_evidence_dao_count_rows( fixture.database ) == 1 ); g_clear_error( &error ); evidence_record_free( second_record ); evidence_record_free( first_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le refus d’un type absent du catalogue SQLite. */ static void test_evidence_dao_insert_unknown_type(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *evidence_record = NULL; GError *error = NULL; evidence_record = evidence_record_new( "88888888-8888-4888-8888-888888888888", "preuve.bin", "preuve_001.bin", "01_Preuves_Originales/Autres/preuve_001.bin", "type_inconnu", 500, "22222222222222222222222222222222" "22222222222222222222222222222222", "2026-07-18T18:20:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(evidence_record != NULL); assert(error == NULL); assert( !evidence_dao_insert( fixture.evidence_dao, evidence_record, &error ) ); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_CONSTRAINT ); assert( strstr( error->message, "type de preuve" ) != NULL ); assert( test_evidence_dao_count_rows( fixture.database ) == 0 ); g_clear_error( &error ); evidence_record_free( evidence_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Crée une base V2 temporaire et son DAO. */ static TestEvidenceDaoFixture test_evidence_dao_fixture_create(void) { TestEvidenceDaoFixture fixture = {0}; GError *error = NULL; fixture.temporary_directory = g_dir_make_tmp( "labfy-evidence-dao-test-XXXXXX", &error ); assert(fixture.temporary_directory != NULL); assert(error == NULL); fixture.database_path = g_build_filename( fixture.temporary_directory, "Enquete.sqlite", NULL ); assert(fixture.database_path != NULL); assert( database_initialize( fixture.database_path, "Enquete_EvidenceDao", fixture.temporary_directory ) ); fixture.database = database_open( fixture.database_path ); assert(fixture.database != NULL); fixture.evidence_dao = evidence_dao_new( fixture.database, &error ); assert(fixture.evidence_dao != NULL); assert(error == NULL); return fixture; } /** * @brief Détruit une fixture et ses fichiers temporaires. */ static void test_evidence_dao_fixture_clear( TestEvidenceDaoFixture *fixture ) { assert(fixture != NULL); evidence_dao_free( fixture->evidence_dao ); database_close( fixture->database ); assert( g_remove( fixture->database_path ) == 0 ); assert( g_rmdir( fixture->temporary_directory ) == 0 ); g_free( fixture->database_path ); g_free( fixture->temporary_directory ); fixture->evidence_dao = NULL; fixture->database = NULL; fixture->database_path = NULL; fixture->temporary_directory = NULL; } /** * @brief Vérifie la création et la libération d’un DAO valide. */ static void test_evidence_dao_new_valid(void) { Database *database = NULL; EvidenceDao *evidence_dao = NULL; GError *error = NULL; database = database_open( ":memory:" ); assert(database != NULL); evidence_dao = evidence_dao_new( database, &error ); assert(evidence_dao != NULL); assert(error == NULL); /* * La libération du DAO ne doit pas fermer Database. */ evidence_dao_free( evidence_dao ); database_close( database ); } /** * @brief Vérifie que la destruction accepte NULL. */ static void test_evidence_dao_free_null(void) { evidence_dao_free( NULL ); } /** * @brief Vérifie l’insertion complète d’une preuve valide. */ static void test_evidence_dao_insert_valid_full(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *evidence_record = NULL; DatabaseStatement *statement = NULL; char *identifier = NULL; char *original_name = NULL; char *internal_name = NULL; char *relative_path = NULL; char *type_identifier = NULL; char *sha256 = NULL; char *imported_at = NULL; char *collected_at = NULL; char *source = NULL; char *description = NULL; int64_t size_bytes = -1; int64_t integrity_status = -1; GError *error = NULL; evidence_record = evidence_record_new( "11111111-1111-4111-8111-111111111111", "Capture Instagram.png", "capture_instagram_001.png", "01_Preuves_Originales/Captures_Ecran/" "capture_instagram_001.png", "screenshot", 4096, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "2026-07-18T16:00:00Z", "2026-07-17T20:30:00Z", "Compte Instagram communiqué par la victime.", "Capture originale de la conversation.", EVIDENCE_INTEGRITY_STATUS_VALID, &error ); assert(evidence_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, evidence_record, &error ) ); assert(error == NULL); statement = database_statement_prepare( fixture.database, "SELECT " " preuves.id," " preuves.original_name," " preuves.name," " preuves.relative_path," " types_preuve.code," " preuves.size_bytes," " preuves.sha256," " preuves.imported_at," " preuves.collected_at," " preuves.source," " preuves.description," " preuves.integrity_status " "FROM preuves " "INNER JOIN types_preuve " "ON types_preuve.id = preuves.type_id " "WHERE preuves.id = ?;" ); assert(statement != NULL); assert( database_statement_bind_text( statement, 1, "11111111-1111-4111-8111-111111111111" ) ); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_ROW ); assert( database_statement_column_text( statement, 0, &identifier ) ); assert( database_statement_column_text( statement, 1, &original_name ) ); assert( database_statement_column_text( statement, 2, &internal_name ) ); assert( database_statement_column_text( statement, 3, &relative_path ) ); assert( database_statement_column_text( statement, 4, &type_identifier ) ); assert( database_statement_column_int64( statement, 5, &size_bytes ) ); assert( database_statement_column_text( statement, 6, &sha256 ) ); assert( database_statement_column_text( statement, 7, &imported_at ) ); assert( database_statement_column_text( statement, 8, &collected_at ) ); assert( database_statement_column_text( statement, 9, &source ) ); assert( database_statement_column_text( statement, 10, &description ) ); assert( database_statement_column_int64( statement, 11, &integrity_status ) ); /* * L’identifiant est unique : aucune seconde ligne ne doit exister. */ assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_DONE ); assert( strcmp( identifier, "11111111-1111-4111-8111-111111111111" ) == 0 ); assert( strcmp( original_name, "Capture Instagram.png" ) == 0 ); assert( strcmp( internal_name, "capture_instagram_001.png" ) == 0 ); assert( strcmp( relative_path, "01_Preuves_Originales/Captures_Ecran/" "capture_instagram_001.png" ) == 0 ); assert( strcmp( type_identifier, "screenshot" ) == 0 ); assert(size_bytes == 4096); assert( strcmp( sha256, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ) == 0 ); assert( strcmp( imported_at, "2026-07-18T16:00:00Z" ) == 0 ); assert( strcmp( collected_at, "2026-07-17T20:30:00Z" ) == 0 ); assert( strcmp( source, "Compte Instagram communiqué par la victime." ) == 0 ); assert( strcmp( description, "Capture originale de la conversation." ) == 0 ); assert( integrity_status == EVIDENCE_INTEGRITY_STATUS_VALID ); database_statement_finalize( statement ); g_free(description); g_free(source); g_free(collected_at); g_free(imported_at); g_free(sha256); g_free(type_identifier); g_free(relative_path); g_free(internal_name); g_free(original_name); g_free(identifier); evidence_record_free( evidence_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie l’insertion d’une preuve dont les champs facultatifs * sont absents. */ static void test_evidence_dao_insert_optional_null(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *evidence_record = NULL; DatabaseStatement *statement = NULL; bool collected_at_is_null = false; bool source_is_null = false; bool description_is_null = false; GError *error = NULL; evidence_record = evidence_record_new( "22222222-2222-4222-8222-222222222222", "document.pdf", "document_001.pdf", "01_Preuves_Originales/Documents/document_001.pdf", "document", 2048, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "2026-07-18T16:30:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(evidence_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, evidence_record, &error ) ); assert(error == NULL); statement = database_statement_prepare( fixture.database, "SELECT " " collected_at," " source," " description " "FROM preuves " "WHERE id = ?;" ); assert(statement != NULL); assert( database_statement_bind_text( statement, 1, "22222222-2222-4222-8222-222222222222" ) ); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_ROW ); assert( database_statement_column_is_null( statement, 0, &collected_at_is_null ) ); assert( database_statement_column_is_null( statement, 1, &source_is_null ) ); assert( database_statement_column_is_null( statement, 2, &description_is_null ) ); assert(collected_at_is_null); assert(source_is_null); assert(description_is_null); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_DONE ); database_statement_finalize( statement ); evidence_record_free( evidence_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie que deux preuves distinctes peuvent partager le même hash. * * Un même fichier peut être présent à plusieurs emplacements ou provenir * de plusieurs collectes. Le SHA-256 ne doit donc pas être unique. */ static void test_evidence_dao_insert_duplicate_sha256(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *first_record = NULL; EvidenceRecord *second_record = NULL; DatabaseStatement *statement = NULL; int64_t evidence_count = -1; GError *error = NULL; const char *shared_sha256 = "cccccccccccccccccccccccccccccccc" "cccccccccccccccccccccccccccccccc"; first_record = evidence_record_new( "33333333-3333-4333-8333-333333333333", "capture_1.png", "capture_001.png", "01_Preuves_Originales/Captures_Ecran/capture_001.png", "screenshot", 1024, shared_sha256, "2026-07-18T17:00:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(first_record != NULL); assert(error == NULL); second_record = evidence_record_new( "44444444-4444-4444-8444-444444444444", "capture_2.png", "capture_002.png", "01_Preuves_Originales/Captures_Ecran/capture_002.png", "screenshot", 1024, shared_sha256, "2026-07-18T17:05:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(second_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, first_record, &error ) ); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, second_record, &error ) ); assert(error == NULL); statement = database_statement_prepare( fixture.database, "SELECT COUNT(*) " "FROM preuves " "WHERE sha256 = ?;" ); assert(statement != NULL); assert( database_statement_bind_text( statement, 1, shared_sha256 ) ); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_ROW ); assert( database_statement_column_int64( statement, 0, &evidence_count ) ); assert(evidence_count == 2); assert( database_statement_step( statement ) == DATABASE_STATEMENT_STEP_DONE ); database_statement_finalize( statement ); evidence_record_free( second_record ); evidence_record_free( first_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie la recherche d’une preuve existante. */ static void test_evidence_dao_find_existing(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *inserted_record = NULL; EvidenceRecord *loaded_record = NULL; GError *error = NULL; inserted_record = evidence_record_new( "99999999-9999-4999-8999-999999999999", "conversation.png", "conversation_001.png", "01_Preuves_Originales/Captures_Ecran/" "conversation_001.png", "screenshot", 8192, "33333333333333333333333333333333" "33333333333333333333333333333333", "2026-07-18T19:00:00Z", "2026-07-17T21:00:00Z", "Conversation Instagram.", "Capture conservée sans modification.", EVIDENCE_INTEGRITY_STATUS_VALID, &error ); assert(inserted_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, inserted_record, &error ) ); assert(error == NULL); loaded_record = evidence_dao_find_by_identifier( fixture.evidence_dao, "99999999-9999-4999-8999-999999999999", &error ); assert(loaded_record != NULL); assert(error == NULL); assert( strcmp( evidence_record_get_identifier( loaded_record ), "99999999-9999-4999-8999-999999999999" ) == 0 ); assert( strcmp( evidence_record_get_original_name( loaded_record ), "conversation.png" ) == 0 ); assert( strcmp( evidence_record_get_type_identifier( loaded_record ), "screenshot" ) == 0 ); assert( evidence_record_get_size_bytes( loaded_record ) == 8192 ); assert( evidence_record_get_integrity_status( loaded_record ) == EVIDENCE_INTEGRITY_STATUS_VALID ); evidence_record_free( loaded_record ); evidence_record_free( inserted_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie qu’une preuve absente retourne NULL sans erreur. */ static void test_evidence_dao_find_missing(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *evidence_record = NULL; GError *error = NULL; evidence_record = evidence_dao_find_by_identifier( fixture.evidence_dao, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", &error ); assert(evidence_record == NULL); assert(error == NULL); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le refus d’un identifiant de recherche invalide. */ static void test_evidence_dao_find_invalid_identifier(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *evidence_record = NULL; GError *error = NULL; evidence_record = evidence_dao_find_by_identifier( fixture.evidence_dao, "identifiant-invalide", &error ); assert(evidence_record == NULL); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_INVALID_ARGUMENT ); g_clear_error( &error ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le comptage d’une table de preuves vide. */ static void test_evidence_dao_count_empty(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); guint64 evidence_count = 42; GError *error = NULL; assert( evidence_dao_count( fixture.evidence_dao, &evidence_count, &error ) ); assert(error == NULL); assert(evidence_count == 0); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le comptage de plusieurs preuves. */ static void test_evidence_dao_count_records(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *first_record = NULL; EvidenceRecord *second_record = NULL; guint64 evidence_count = 0; GError *error = NULL; first_record = evidence_record_new( "aaaaaaaa-1111-4111-8111-111111111111", "preuve_1.png", "preuve_001.png", "01_Preuves_Originales/Captures_Ecran/preuve_001.png", "screenshot", 1000, "44444444444444444444444444444444" "44444444444444444444444444444444", "2026-07-18T19:30:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(first_record != NULL); assert(error == NULL); second_record = evidence_record_new( "bbbbbbbb-2222-4222-8222-222222222222", "preuve_2.pdf", "preuve_002.pdf", "01_Preuves_Originales/Documents/preuve_002.pdf", "document", 2000, "55555555555555555555555555555555" "55555555555555555555555555555555", "2026-07-18T19:35:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(second_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, first_record, &error ) ); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, second_record, &error ) ); assert(error == NULL); assert( evidence_dao_count( fixture.evidence_dao, &evidence_count, &error ) ); assert(error == NULL); assert(evidence_count == 2); evidence_record_free( second_record ); evidence_record_free( first_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le refus des paramètres de comptage invalides. */ static void test_evidence_dao_count_invalid_arguments(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); guint64 evidence_count = 123; GError *error = NULL; assert( !evidence_dao_count( NULL, &evidence_count, &error ) ); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_INVALID_ARGUMENT ); /* * Le DAO absent empêche la fonction d’accéder à la destination. */ assert(evidence_count == 123); g_clear_error( &error ); assert( !evidence_dao_count( fixture.evidence_dao, NULL, &error ) ); assert(error != NULL); assert( error->code == (gint) EVIDENCE_DAO_ERROR_INVALID_ARGUMENT ); g_clear_error( &error ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le chargement d’une liste vide. */ static void test_evidence_dao_list_empty(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); GPtrArray *evidence_records = NULL; GError *error = NULL; evidence_records = evidence_dao_list_all( fixture.evidence_dao, &error ); assert(evidence_records != NULL); assert(error == NULL); assert(evidence_records->len == 0); g_ptr_array_unref( evidence_records ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le chargement de plusieurs preuves dans un ordre stable. */ static void test_evidence_dao_list_order(void) { TestEvidenceDaoFixture fixture = test_evidence_dao_fixture_create(); EvidenceRecord *first_inserted_record = NULL; EvidenceRecord *second_inserted_record = NULL; EvidenceRecord *third_inserted_record = NULL; const EvidenceRecord *first_loaded_record = NULL; const EvidenceRecord *second_loaded_record = NULL; const EvidenceRecord *third_loaded_record = NULL; GPtrArray *evidence_records = NULL; GError *error = NULL; /* * Cette preuve est insérée en premier, mais sa date est la plus tardive. */ third_inserted_record = evidence_record_new( "30000000-0000-4000-8000-000000000003", "preuve_tardive.pdf", "preuve_tardive.pdf", "01_Preuves_Originales/Documents/preuve_tardive.pdf", "document", 3000, "66666666666666666666666666666666" "66666666666666666666666666666666", "2026-07-18T21:00:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(third_inserted_record != NULL); assert(error == NULL); second_inserted_record = evidence_record_new( "20000000-0000-4000-8000-000000000002", "preuve_b.png", "preuve_b.png", "01_Preuves_Originales/Captures_Ecran/preuve_b.png", "screenshot", 2000, "77777777777777777777777777777777" "77777777777777777777777777777777", "2026-07-18T20:00:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(second_inserted_record != NULL); assert(error == NULL); first_inserted_record = evidence_record_new( "10000000-0000-4000-8000-000000000001", "preuve_a.png", "preuve_a.png", "01_Preuves_Originales/Captures_Ecran/preuve_a.png", "screenshot", 1000, "88888888888888888888888888888888" "88888888888888888888888888888888", "2026-07-18T20:00:00Z", NULL, NULL, NULL, EVIDENCE_INTEGRITY_STATUS_UNKNOWN, &error ); assert(first_inserted_record != NULL); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, third_inserted_record, &error ) ); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, second_inserted_record, &error ) ); assert(error == NULL); assert( evidence_dao_insert( fixture.evidence_dao, first_inserted_record, &error ) ); assert(error == NULL); evidence_records = evidence_dao_list_all( fixture.evidence_dao, &error ); assert(evidence_records != NULL); assert(error == NULL); assert(evidence_records->len == 3); first_loaded_record = g_ptr_array_index( evidence_records, 0 ); second_loaded_record = g_ptr_array_index( evidence_records, 1 ); third_loaded_record = g_ptr_array_index( evidence_records, 2 ); assert(first_loaded_record != NULL); assert(second_loaded_record != NULL); assert(third_loaded_record != NULL); /* * Les deux premières preuves partagent la même date. * Leur identifiant sert donc de second critère de tri. */ assert( strcmp( evidence_record_get_identifier( first_loaded_record ), "10000000-0000-4000-8000-000000000001" ) == 0 ); assert( strcmp( evidence_record_get_identifier( second_loaded_record ), "20000000-0000-4000-8000-000000000002" ) == 0 ); assert( strcmp( evidence_record_get_identifier( third_loaded_record ), "30000000-0000-4000-8000-000000000003" ) == 0 ); /* * Le tableau libère lui-même les trois modèles chargés. */ g_ptr_array_unref( evidence_records ); evidence_record_free( first_inserted_record ); evidence_record_free( second_inserted_record ); evidence_record_free( third_inserted_record ); test_evidence_dao_fixture_clear( &fixture ); } /** * @brief Vérifie le refus d’un DAO absent. */ static void test_evidence_dao_list_invalid_arguments(void) { GPtrArray *evidence_records = NULL; GError *error = NULL; evidence_records = evidence_dao_list_all( NULL, &error ); assert(evidence_records == NULL); assert(error != NULL); assert(error->domain == EVIDENCE_DAO_ERROR); assert( error->code == (gint) EVIDENCE_DAO_ERROR_INVALID_ARGUMENT ); g_clear_error( &error ); } int main(void) { test_evidence_dao_new_null_database(); test_evidence_dao_new_valid(); test_evidence_dao_free_null(); test_evidence_dao_insert_valid_full(); test_evidence_dao_insert_valid_full(); test_evidence_dao_insert_optional_null(); test_evidence_dao_insert_duplicate_sha256(); test_evidence_dao_insert_duplicate_identifier(); test_evidence_dao_insert_duplicate_relative_path(); test_evidence_dao_insert_unknown_type(); test_evidence_dao_find_existing(); test_evidence_dao_find_missing(); test_evidence_dao_find_invalid_identifier(); test_evidence_dao_count_empty(); test_evidence_dao_count_records(); test_evidence_dao_count_invalid_arguments(); test_evidence_dao_list_empty(); test_evidence_dao_list_order(); test_evidence_dao_list_invalid_arguments(); printf( "EvidenceDao : tests de construction valides.\n" ); return 0; }