test_image_repository.c

Go to the documentation of this file.

/*
    This file is part of Ansel,
    Copyright (C) 2026 Aurélien PIERRE.
 
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Ansel 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "testdb.h"
 
 
// an arbitrary flag bit with no side meaning in these tests
#define TEST_FLAG 2048
 
static void test_flag_among_multi_image(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/filmroll");
  assert_true(film > 0);
  const int32_t a = testdb_make_image(film, "a.raw");
  const int32_t b = testdb_make_image(film, "b.raw");
  const int32_t c = testdb_make_image(film, "c.raw");
  assert_true(a > 0 && b > 0 && c > 0);
 
  GList *two = g_list_append(g_list_append(NULL, GINT_TO_POINTER(a)), GINT_TO_POINTER(b));
  GList *all = g_list_append(g_list_copy(two), GINT_TO_POINTER(c));
 
  // set the flag on TWO images at once -- the case the old IN (?) binding silently dropped
  assert_true(dt_image_repository_set_flag_among(two, TEST_FLAG));
 
  GList *flagged = dt_image_repository_get_ids_with_flag_among(all, TEST_FLAG);
  assert_int_equal(g_list_length(flagged), 2);
  assert_int_equal(GPOINTER_TO_INT(flagged->data), a);
  assert_int_equal(GPOINTER_TO_INT(flagged->next->data), b);
  g_list_free(flagged);
 
  // a single-element list keeps working (the only case the old binding handled)
  GList *one = g_list_append(NULL, GINT_TO_POINTER(a));
  flagged = dt_image_repository_get_ids_with_flag_among(one, TEST_FLAG);
  assert_int_equal(g_list_length(flagged), 1);
  assert_int_equal(GPOINTER_TO_INT(flagged->data), a);
  g_list_free(flagged);
 
  // an empty set asks about nothing
  assert_null(dt_image_repository_get_ids_with_flag_among(NULL, TEST_FLAG));
 
  g_list_free(one);
  g_list_free(two);
  g_list_free(all);
}
 
/* dt_image_repository_set_flags_masked() writes the mask's bits and nothing else.
 *
 * The XMP crawler reads an image's whole `flags` word, then lists a directory -- a
 * filesystem round-trip -- before deciding what to write back. Anything the user changes in
 * that window (a star rating, a colour label) shares the word, so the crawl must write only
 * the two bits it owns. This pins that. */
static void test_set_flags_masked_leaves_other_bits(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/masked");
  assert_true(film > 0);
  const int32_t img = testdb_make_image(film, "masked.raw");
  assert_true(img > 0);
 
  // two bits the write will own, and one standing in for the rating the user sets meanwhile
  const int owned_a = 1 << 4;
  const int owned_b = 1 << 5;
  const int mask = owned_a | owned_b;
 
  GList *one = g_list_append(NULL, GINT_TO_POINTER(img));
 
  // start with owned_a set and owned_b clear, plus the unrelated bit
  assert_true(dt_image_repository_set_flag_among(one, owned_a | TEST_FLAG));
 
  // the crawl's write: clear owned_a, set owned_b, say nothing about the rest
  assert_true(dt_image_repository_set_flags_masked(img, mask, owned_b));
 
  GList *got = dt_image_repository_get_ids_with_flag_among(one, owned_b);
  assert_int_equal(g_list_length(got), 1);
  g_list_free(got);
 
  assert_null(dt_image_repository_get_ids_with_flag_among(one, owned_a));
 
  // the bit outside the mask survived -- this is the whole point
  got = dt_image_repository_get_ids_with_flag_among(one, TEST_FLAG);
  assert_int_equal(g_list_length(got), 1);
  g_list_free(got);
 
  // an empty mask writes nothing and says so, rather than clearing the word
  assert_false(dt_image_repository_set_flags_masked(img, 0, 0));
  got = dt_image_repository_get_ids_with_flag_among(one, TEST_FLAG);
  assert_int_equal(g_list_length(got), 1);
  g_list_free(got);
 
  g_list_free(one);
}
 
static void test_full_paths(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/paths");
  const int32_t a = testdb_make_image(film, "a.raw");
  const int32_t b = testdb_make_image(film, "b.raw");
  assert_true(a > 0 && b > 0);
 
  GList *ids = g_list_append(g_list_append(NULL, GINT_TO_POINTER(a)), GINT_TO_POINTER(b));
  GList *paths = dt_image_repository_get_full_paths(ids);
  assert_int_equal(g_list_length(paths), 2);
  assert_string_equal((const char *)paths->data, "/testdb/paths/a.raw");
  assert_string_equal((const char *)paths->next->data, "/testdb/paths/b.raw");
  g_list_free_full(paths, g_free);
  g_list_free(ids);
}
 
static void test_id_range(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/range");
  const int32_t a = testdb_make_image(film, "a.raw");
  const int32_t b = testdb_make_image(film, "b.raw");
  const int32_t c = testdb_make_image(film, "c.raw");
  assert_true(a > 0 && c > a);
 
  assert_int_equal(dt_image_repository_count_in_id_range(a, c), 3);
  assert_int_equal(dt_image_repository_count_in_id_range(b, b), 1);
  assert_int_equal(dt_image_repository_count_in_id_range(c + 1, c + 100), 0);
}
 
static void test_write_timestamp_is_64bit(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/ts");
  const int32_t a = testdb_make_image(film, "a.raw");
  assert_true(a > 0);
 
  // 2100-01-01: overflows a 32-bit time_t. The caller this setter replaced bound the
  // timestamp with sqlite3_bind_int(), which truncates in 2038.
  const int64_t year2100 = 4102444800LL;
  assert_true(dt_image_repository_set_write_timestamp(a, year2100));
  assert_true(dt_image_repository_get_write_timestamp(a) == year2100);
}
 
static void test_group_member_rows(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/group");
  const int32_t a = testdb_make_image(film, "a.raw");
  const int32_t b = testdb_make_image(film, "b.raw");
  assert_true(a > 0 && b > 0);
  assert_true(dt_image_repository_set_group(a, a));
  assert_true(dt_image_repository_set_group(b, a));
 
  GList *members = dt_image_repository_get_group_member_rows(a);
  assert_int_equal(g_list_length(members), 2);
  const dt_image_group_member_t *first = (const dt_image_group_member_t *)members->data;
  const dt_image_group_member_t *second = (const dt_image_group_member_t *)members->next->data;
  assert_int_equal(first->imgid, a);
  assert_string_equal(first->filename, "a.raw");
  assert_int_equal(second->imgid, b);
  assert_string_equal(second->filename, "b.raw");
  g_list_free_full(members, dt_image_group_member_free);
}
 
static void test_count_distinct_fields(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/distinct");
  const int32_t a = testdb_make_image(film, "a.raw");
  const int32_t b = testdb_make_image(film, "b.raw");
  assert_true(a > 0 && b > 0);
 
  GList *ids = g_list_append(g_list_append(NULL, GINT_TO_POINTER(a)), GINT_TO_POINTER(b));
  int *counts = dt_image_repository_count_distinct_fields(ids);
  assert_non_null(counts);
 
  assert_int_equal(counts[DT_IMAGE_FIELD_FILM_ROLL], 1); // same film -> agree
  assert_int_equal(counts[DT_IMAGE_FIELD_FILENAME], 2);  // different names -> disagree
  assert_int_equal(counts[DT_IMAGE_FIELD_IMGID], 2);     // ids differ by definition
  assert_int_equal(counts[DT_IMAGE_FIELD_VERSION], 1);   // both imported at version 0
 
  free(counts);
  g_list_free(ids);
 
  // the empty set answers nothing rather than something
  assert_null(dt_image_repository_count_distinct_fields(NULL));
}
 
static gboolean _count_two_rows(const int32_t imgid, const int64_t write_timestamp,
                                const int version, const char *image_path, const int flags,
                                void *user_data)
{
  (void)imgid;
  (void)write_timestamp;
  (void)version;
  (void)image_path;
  (void)flags;
  int *seen = (int *)user_data;
  (*seen)++;
  return *seen < 2; // refuse the second row
}
 
/* The walk ends at the first row the callback refuses. That is how the XMP crawler stops when
 * Ansel quits; a walk that went on regardless would hold the quit up until the last image. */
static void test_foreach_with_path_stops_when_asked(void **state)
{
  (void)state;
  const int32_t film = testdb_make_film("/testdb/walk");
  assert_true(film > 0);
  assert_true(testdb_make_image(film, "w0.raw") > 0);
  assert_true(testdb_make_image(film, "w1.raw") > 0);
  assert_true(testdb_make_image(film, "w2.raw") > 0);
 
  int seen = 0;
  dt_image_repository_foreach_with_path(_count_two_rows, &seen);
  assert_int_equal(seen, 2);
}
 
int main(void)
{
  const struct CMUnitTest tests[] = {
    cmocka_unit_test(test_flag_among_multi_image),
    cmocka_unit_test(test_set_flags_masked_leaves_other_bits),
    cmocka_unit_test(test_full_paths),
    cmocka_unit_test(test_id_range),
    cmocka_unit_test(test_write_timestamp_is_64bit),
    cmocka_unit_test(test_group_member_rows),
    cmocka_unit_test(test_count_distinct_fields),
    cmocka_unit_test(test_foreach_with_path_stops_when_asked),
  };
  return cmocka_run_group_tests(tests, testdb_setup, testdb_teardown);
}