tests/dconf-mock-gvdb.c

   1 #include "../gvdb/gvdb-reader.h"
   2 #include "dconf-mock.h"
   3
   4 /* The global dconf_mock_gvdb_tables hashtable is modified all the time
   5  * so we need to hold the lock while we access it.
   6  *
   7  * The hashtables contained within it are never modified, however.  They
   8  * can be safely accessed without a lock.
   9  */
  10
  11 static GHashTable *dconf_mock_gvdb_tables;
  12 static GMutex      dconf_mock_gvdb_lock;
  13
  14 typedef struct
  15 {
  16   GVariant  *value;
  17   GvdbTable *table;
  18 } DConfMockGvdbItem;
  19
  20 struct _GvdbTable
  21 {
  22   GHashTable *table;
  23   gboolean    is_valid;
  24   gboolean    top_level;
  25   gint        ref_count;
  26 };
  27
  28 static void
  29 dconf_mock_gvdb_item_free (gpointer data)
  30 {
  31   DConfMockGvdbItem *item = data;
  32
  33   if (item->value)
  34     g_variant_unref (item->value);
  35
  36   if (item->table)
  37     gvdb_table_free (item->table);
  38
  39   g_slice_free (DConfMockGvdbItem, item);
  40 }
  41
  42 static void
  43 dconf_mock_gvdb_init (void)
  44 {
  45   if (dconf_mock_gvdb_tables == NULL)
  46     dconf_mock_gvdb_tables = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) gvdb_table_free);
  47 }
  48
  49 GvdbTable *
  50 dconf_mock_gvdb_table_new (void)
  51 {
  52   GvdbTable *table;
  53
  54   table = g_slice_new (GvdbTable);
  55   table->table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, dconf_mock_gvdb_item_free);
  56   table->ref_count = 1;
  57   table->is_valid = TRUE;
  58
  59   return table;
  60 }
  61
  62 void
  63 dconf_mock_gvdb_table_insert (GvdbTable   *table,
  64                               const gchar *name,
  65                               GVariant    *value,
  66                               GvdbTable   *subtable)
  67 {
  68   DConfMockGvdbItem *item;
  69
  70   g_assert (value == NULL || subtable == NULL);
  71
  72   if (subtable)
  73     subtable->top_level = FALSE;
  74
  75   item = g_slice_new (DConfMockGvdbItem);
  76   item->value = value ? g_variant_ref_sink (value) : NULL;
  77   item->table = subtable;
  78
  79   g_hash_table_insert (table->table, g_strdup (name), item);
  80 }
  81
  82 void
  83 dconf_mock_gvdb_install (const gchar *filename,
  84                          GvdbTable   *table)
  85 {
  86   g_mutex_lock (&dconf_mock_gvdb_lock);
  87   dconf_mock_gvdb_init ();
  88
  89   if (table)
  90     {
  91       table->top_level = TRUE;
  92       g_hash_table_insert (dconf_mock_gvdb_tables, g_strdup (filename), table);
  93     }
  94   else
  95     g_hash_table_remove (dconf_mock_gvdb_tables, filename);
  96
  97   g_mutex_unlock (&dconf_mock_gvdb_lock);
  98 }
  99
 100 void
 101 gvdb_table_free (GvdbTable *table)
 102 {
 103   if (g_atomic_int_dec_and_test (&table->ref_count))
 104     {
 105       g_hash_table_unref (table->table);
 106       g_slice_free (GvdbTable, table);
 107     }
 108 }
 109
 110 GvdbTable *
 111 dconf_mock_gvdb_table_ref (GvdbTable *table)
 112 {
 113   g_atomic_int_inc (&table->ref_count);
 114
 115   return table;
 116 }
 117
 118 GvdbTable *
 119 gvdb_table_get_table (GvdbTable   *table,
 120                       const gchar *key)
 121 {
 122   DConfMockGvdbItem *item;
 123   GvdbTable *subtable;
 124
 125   item = g_hash_table_lookup (table->table, key);
 126
 127   if (item && item->table)
 128     subtable = dconf_mock_gvdb_table_ref (item->table);
 129   else
 130     subtable = NULL;
 131
 132   return subtable;
 133 }
 134
 135 gboolean
 136 gvdb_table_has_value (GvdbTable   *table,
 137                       const gchar *key)
 138 {
 139   DConfMockGvdbItem *item;
 140
 141   item = g_hash_table_lookup (table->table, key);
 142
 143   return item && item->value;
 144 }
 145
 146 GVariant *
 147 gvdb_table_get_value (GvdbTable   *table,
 148                       const gchar *key)
 149 {
 150   DConfMockGvdbItem *item;
 151
 152   item = g_hash_table_lookup (table->table, key);
 153
 154   return (item && item->value) ? g_variant_ref (item->value) : NULL;
 155 }
 156
 157 gchar **
 158 gvdb_table_list (GvdbTable   *table,
 159                  const gchar *key)
 160 {
 161   const gchar * const result[] = { "value", NULL };
 162
 163   g_assert_cmpstr (key, ==, "/");
 164
 165   if (!gvdb_table_has_value (table, "/value"))
 166     return NULL;
 167
 168   return g_strdupv ((gchar **) result);
 169 }
 170
 171 GvdbTable *
 172 gvdb_table_new (const gchar  *filename,
 173                 gboolean      trusted,
 174                 GError      **error)
 175 {
 176   GvdbTable *table;
 177
 178   g_mutex_lock (&dconf_mock_gvdb_lock);
 179   dconf_mock_gvdb_init ();
 180   table = g_hash_table_lookup (dconf_mock_gvdb_tables, filename);
 181   if (table)
 182     dconf_mock_gvdb_table_ref (table);
 183   g_mutex_unlock (&dconf_mock_gvdb_lock);
 184
 185   if (table == NULL)
 186     g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT, "this gvdb does not exist");
 187
 188   return table;
 189 }
 190
 191 gboolean
 192 gvdb_table_is_valid (GvdbTable *table)
 193 {
 194   return table->is_valid;
 195 }
 196
 197 void
 198 dconf_mock_gvdb_table_invalidate (GvdbTable *table)
 199 {
 200   table->is_valid = FALSE;
 201 }