test_conf_value_lifetime.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 "common/conf.h"
#include "darktable.h"
 
#include <glib.h>
#include <glib/gstdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>  // calloc/free, used directly below
// cmocka.h declares `extern jmp_buf global_expect_assert_env' at file scope without including
// <setjmp.h> itself. Same suppression as test_pipe_cache_policy.c, and for the same reason.
#include <setjmp.h>  // NOLINT(misc-include-cleaner)
#include <stdint.h>
#include <cmocka.h>
 
#ifdef _WIN32
#include "win/main_wrapper.h"
#endif
 
#define TEST_KEY "plugins/test/conf_value_lifetime"
 
static char *_rcfile = NULL;
 
static int _setup(void **state)
{
  (void)state;
  // dt_conf_init() writes through the darktable.conf global, so it must point at the
  // instance being initialised before the call -- exactly as dt_init() does it.
  _rcfile = g_build_filename(g_get_tmp_dir(), "ansel_test_conf_lifetime.rc", NULL);
  g_remove(_rcfile);
  darktable.conf = (dt_conf_t *)calloc(1, sizeof(dt_conf_t));
  dt_conf_init(darktable.conf, _rcfile, NULL);
  return 0;
}
 
static int _teardown(void **state)
{
  (void)state;
  dt_conf_cleanup(darktable.conf);
  free(darktable.conf);
  darktable.conf = NULL;
  g_remove(_rcfile);
  g_free(_rcfile);
  _rcfile = NULL;
  return 0;
}
 
static void _borrowed_value_survives_being_replaced(void **state)
{
  (void)state;
  dt_conf_set_string(TEST_KEY, "first");
 
  const char *borrowed = dt_conf_get_string_const(TEST_KEY);
  assert_string_equal(borrowed, "first");
 
  // The write that used to free `borrowed` out from under us.
  dt_conf_set_string(TEST_KEY, "second");
 
  // Still readable, and still the value it was read as. Under ASAN, a regression here is a
  // heap-use-after-free rather than a failed assertion.
  assert_string_equal(borrowed, "first");
 
  // ... while a fresh read observes the new value. Stale, not wrong.
  assert_string_equal(dt_conf_get_string_const(TEST_KEY), "second");
}
 
static void _every_displaced_value_stays_readable(void **state)
{
  (void)state;
  const char *held[8];
 
  for(int i = 0; i < 8; i++)
  {
    char *value = g_strdup_printf("value-%d", i);
    dt_conf_set_string(TEST_KEY, value);
    g_free(value);
    held[i] = dt_conf_get_string_const(TEST_KEY);
  }
 
  // Every pointer taken along the way still reads as what it was when taken.
  for(int i = 0; i < 8; i++)
  {
    char *expected = g_strdup_printf("value-%d", i);
    assert_string_equal(held[i], expected);
    g_free(expected);
  }
}
 
static void _rewriting_the_same_value_retires_nothing(void **state)
{
  (void)state;
  dt_conf_set_string(TEST_KEY, "unchanged");
  const char *before = dt_conf_get_string_const(TEST_KEY);
 
  for(int i = 0; i < 16; i++) dt_conf_set_string(TEST_KEY, "unchanged");
 
  // Same allocation, so nothing was displaced and nothing was retired.
  assert_ptr_equal(before, dt_conf_get_string_const(TEST_KEY));
  assert_string_equal(before, "unchanged");
}
 
static void _typed_setters_retire_too(void **state)
{
  (void)state;
  dt_conf_set_int(TEST_KEY, 11);
  const char *borrowed = dt_conf_get_string_const(TEST_KEY);
  assert_string_equal(borrowed, "11");
 
  dt_conf_set_int(TEST_KEY, 22);
 
  assert_string_equal(borrowed, "11");
  assert_int_equal(dt_conf_get_int_fast(TEST_KEY), 22);
}
 
static void _the_generation_advances_on_a_change_and_not_otherwise(void **state)
{
  (void)state;
  dt_conf_set_string(TEST_KEY, "first");
  const uint64_t after_first = dt_conf_generation();
  assert_true(after_first > 0);   // starts at 1, so 0 is usable as "nothing cached yet"
 
  dt_conf_set_string(TEST_KEY, "second");
  const uint64_t after_second = dt_conf_generation();
  assert_true(after_second > after_first);
 
  // An idle rewrite of the identical value must NOT move it.
  for(int i = 0; i < 16; i++) dt_conf_set_string(TEST_KEY, "second");
  assert_int_equal(dt_conf_generation(), after_second);
 
  // The typed setters go through the same writer, so they advance it too.
  dt_conf_set_int(TEST_KEY, 7);
  const uint64_t after_int = dt_conf_generation();
  assert_true(after_int > after_second);
 
  dt_conf_set_int(TEST_KEY, 7);
  assert_int_equal(dt_conf_generation(), after_int);
 
  // And a plain read never moves it -- a cache that re-derived per read would be no cache.
  (void)dt_conf_get_int_fast(TEST_KEY);
  (void)dt_conf_get_string_const(TEST_KEY);
  assert_int_equal(dt_conf_generation(), after_int);
}
 
int main(int argc, char *argv[])
{
  const struct CMUnitTest tests[] = {
    cmocka_unit_test(_borrowed_value_survives_being_replaced),
    cmocka_unit_test(_every_displaced_value_stays_readable),
    cmocka_unit_test(_rewriting_the_same_value_retires_nothing),
    cmocka_unit_test(_typed_setters_retire_too),
    cmocka_unit_test(_the_generation_advances_on_a_change_and_not_otherwise),
  };
 
  return cmocka_run_group_tests(tests, _setup, _teardown);
}
 
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on