tests/gvdb.c

   1 #include <glib.h>
   2 #include "gvdb-reader.h"
   3
   4 static void
   5 test_reader_open_error (void)
   6 {
   7   GError *error = NULL;
   8   GvdbTable *table;
   9
  10   table = gvdb_table_new (SRCDIR "/gvdbs/does_not_exist", TRUE, &error);
  11   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
  12   g_assert (table == NULL);
  13   g_clear_error (&error);
  14
  15   table = gvdb_table_new (SRCDIR "/gvdbs/file_empty", TRUE, &error);
  16   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_INVAL);
  17   g_assert (table == NULL);
  18   g_clear_error (&error);
  19
  20   table = gvdb_table_new (SRCDIR "/gvdbs/invalid_header", TRUE, &error);
  21   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_INVAL);
  22   g_assert (table == NULL);
  23   g_clear_error (&error);
  24
  25   table = gvdb_table_new (SRCDIR "/gvdbs/file_too_small", TRUE, &error);
  26   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_INVAL);
  27   g_assert (table == NULL);
  28   g_clear_error (&error);
  29 }
  30
  31 static void
  32 test_reader_empty (void)
  33 {
  34   const gchar * strings[] = { "", "value", "/value", ".", NULL};
  35   GError *error = NULL;
  36   GvdbTable *table;
  37   gint i;
  38
  39   table = gvdb_table_new (SRCDIR "/gvdbs/empty_gvdb", TRUE, &error);
  40   g_assert_no_error (error);
  41   g_assert (table != NULL);
  42
  43   g_assert (gvdb_table_is_valid (table));
  44
  45   for (i = 0; strings[i]; i++)
  46     {
  47       const gchar *key = strings[i];
  48       GvdbTable *sub;
  49       GVariant *val;
  50       gboolean has;
  51       gchar **list;
  52
  53       sub = gvdb_table_get_table (table, key);
  54       g_assert (sub == NULL);
  55
  56       has = gvdb_table_has_value (table, key);
  57       g_assert (!has);
  58
  59       val = gvdb_table_get_value (table, key);
  60       g_assert (val == NULL);
  61
  62       val = gvdb_table_get_raw_value (table, key);
  63       g_assert (val == NULL);
  64
  65       list = gvdb_table_list (table, key);
  66       g_assert (list == NULL);
  67     }
  68
  69   gvdb_table_unref (table);
  70 }
  71
  72 static void
  73 verify_table (GvdbTable *table)
  74 {
  75   GVariant *value;
  76   gchar **list;
  77   gboolean has;
  78
  79   list = gvdb_table_list (table, "/");
  80   g_assert (list != NULL);
  81   g_assert_cmpint (g_strv_length (list), ==, 1);
  82   g_assert_cmpstr (list[0], ==, "values/");
  83   g_strfreev (list);
  84
  85   list = gvdb_table_list (table, "/values/");
  86   g_assert (list != NULL);
  87   g_assert_cmpint (g_strv_length (list), ==, 3);
  88   g_assert_cmpstr (list[0], ==, "boolean");
  89   g_assert_cmpstr (list[1], ==, "int32");
  90   g_assert_cmpstr (list[2], ==, "string");
  91   g_strfreev (list);
  92
  93   /* A directory is not a value */
  94   has = gvdb_table_has_value (table, "/");
  95   g_assert (!has);
  96   has = gvdb_table_has_value (table, "/values/");
  97   g_assert (!has);
  98
  99   has = gvdb_table_has_value (table, "/int32");
 100   g_assert (!has);
 101   has = gvdb_table_has_value (table, "values/int32");
 102   g_assert (!has);
 103   has = gvdb_table_has_value (table, "/values/int32");
 104   g_assert (has);
 105
 106   value = gvdb_table_get_value (table, "/");
 107   g_assert (value == NULL);
 108   value = gvdb_table_get_value (table, "/values/");
 109   g_assert (value == NULL);
 110   value = gvdb_table_get_value (table, "/int32");
 111   g_assert (value == NULL);
 112   value = gvdb_table_get_value (table, "values/int32");
 113   g_assert (value == NULL);
 114
 115   value = gvdb_table_get_value (table, "/values/boolean");
 116   g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN));
 117   g_assert (g_variant_get_boolean (value));
 118   g_variant_unref (value);
 119
 120   value = gvdb_table_get_raw_value (table, "/values/boolean");
 121   g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN));
 122   g_assert (g_variant_get_boolean (value));
 123   g_variant_unref (value);
 124
 125   value = gvdb_table_get_value (table, "/values/int32");
 126   g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32));
 127   g_assert_cmpint (g_variant_get_int32 (value), ==, 0x44332211);
 128   g_variant_unref (value);
 129
 130   value = gvdb_table_get_value (table, "/values/string");
 131   g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING));
 132   g_assert_cmpstr (g_variant_get_string (value, NULL), ==, "a string");
 133   g_variant_unref (value);
 134
 135   value = gvdb_table_get_raw_value (table, "/values/string");
 136   g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_STRING));
 137   g_assert_cmpstr (g_variant_get_string (value, NULL), ==, "a string");
 138   g_variant_unref (value);
 139 }
 140
 141 static void
 142 test_reader_values (void)
 143 {
 144   GError *error = NULL;
 145   GvdbTable *table;
 146
 147   table = gvdb_table_new (SRCDIR "/gvdbs/example_gvdb", TRUE, &error);
 148   g_assert_no_error (error);
 149   verify_table (table);
 150
 151 #if G_BYTE_ORDER == G_BIG_ENDIAN
 152   {
 153     GVariant *value;
 154
 155     value = gvdb_table_get_raw_value (table, "/values/int32");
 156     g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32));
 157     g_assert_cmpint (g_variant_get_int32 (value), ==, 0x11223344);
 158     g_variant_unref (value);
 159   }
 160 #endif
 161
 162   gvdb_table_unref (table);
 163 }
 164
 165 static void
 166 test_reader_values_bigendian (void)
 167 {
 168   GError *error = NULL;
 169   GvdbTable *table;
 170
 171   table = gvdb_table_new (SRCDIR "/gvdbs/example_gvdb.big-endian", TRUE, &error);
 172   g_assert_no_error (error);
 173   verify_table (table);
 174
 175 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
 176   {
 177     GVariant *value;
 178
 179     value = gvdb_table_get_raw_value (table, "/values/int32");
 180     g_assert (value != NULL && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32));
 181     g_assert_cmpint (g_variant_get_int32 (value), ==, 0x11223344);
 182     g_variant_unref (value);
 183   }
 184 #endif
 185
 186   gvdb_table_unref (table);
 187 }
 188
 189 static gint accept_this_many_opens;
 190
 191 static gboolean
 192 walk_open (const gchar *name,
 193            gsize        name_len,
 194            gpointer     user_data)
 195 {
 196   GString *log = user_data;
 197
 198   g_string_append (log, "'");
 199   g_string_append_len (log, name, name_len);
 200   g_string_append_printf (log, "\'(%zd): {", name_len);
 201
 202   if (accept_this_many_opens)
 203     {
 204       accept_this_many_opens--;
 205       return TRUE;
 206     }
 207
 208   g_string_append (log, "rejected}");
 209
 210   return FALSE;
 211 }
 212
 213 static void
 214 walk_value (const gchar *name,
 215             gsize        name_len,
 216             GVariant    *value,
 217             gpointer     user_data)
 218 {
 219   GString *log = user_data;
 220   gchar *printed;
 221
 222   printed = g_variant_print (value, FALSE);
 223
 224   g_string_append (log, "'");
 225   g_string_append_len (log, name, name_len);
 226   g_string_append_printf (log, "\'(%zd): %s", name_len, printed);
 227   g_free (printed);
 228 }
 229
 230 static void
 231 walk_close (gsize    name_len,
 232             gpointer user_data)
 233 {
 234   GString *log = user_data;
 235
 236   g_string_append_printf (log, "(%zd)}", name_len);
 237 }
 238
 239 static void
 240 verify_walk (GvdbTable *table)
 241 {
 242   GString *log;
 243
 244   log = g_string_new (NULL);
 245   accept_this_many_opens = 2;
 246   gvdb_table_walk (table, "/", walk_open, walk_value, walk_close, log);
 247   g_assert_cmpstr (log->str, ==,
 248                    "'/'(1): {"
 249                      "'values/'(7): {"
 250                        "'boolean'(7): true"
 251                        "'int32'(5): 1144201745"
 252                        "'string'(6): 'a string'"
 253                      "(7)}"
 254                    "(1)}");
 255   g_string_truncate (log, 0);
 256
 257   accept_this_many_opens = 1;
 258   gvdb_table_walk (table, "/", walk_open, walk_value, walk_close, log);
 259   g_assert_cmpstr (log->str, ==,
 260                    "'/'(1): {"
 261                      "'values/'(7): {rejected}"
 262                    "(1)}");
 263   g_string_truncate (log, 0);
 264
 265   accept_this_many_opens = 0;
 266   gvdb_table_walk (table, "/", walk_open, walk_value, walk_close, log);
 267   g_assert_cmpstr (log->str, ==, "'/'(1): {rejected}");
 268   g_string_free (log, TRUE);
 269 }
 270
 271 static void
 272 test_reader_walk (void)
 273 {
 274   GError *error = NULL;
 275   GvdbTable *table;
 276
 277   table = gvdb_table_new (SRCDIR "/gvdbs/example_gvdb", TRUE, &error);
 278   g_assert_no_error (error);
 279
 280   verify_walk (table);
 281
 282   gvdb_table_unref (table);
 283 }
 284
 285 static void
 286 test_reader_walk_bigendian (void)
 287 {
 288   GError *error = NULL;
 289   GvdbTable *table;
 290
 291   table = gvdb_table_new (SRCDIR "/gvdbs/example_gvdb.big-endian", TRUE, &error);
 292   g_assert_no_error (error);
 293
 294   verify_walk (table);
 295
 296   gvdb_table_unref (table);
 297 }
 298
 299 int
 300 main (int argc, char **argv)
 301 {
 302   g_test_init (&argc, &argv, NULL);
 303
 304   g_test_add_func ("/gvdb/reader/open-error", test_reader_open_error);
 305   g_test_add_func ("/gvdb/reader/empty", test_reader_empty);
 306   g_test_add_func ("/gvdb/reader/values", test_reader_values);
 307   g_test_add_func ("/gvdb/reader/values/big-endian", test_reader_values_bigendian);
 308   g_test_add_func ("/gvdb/reader/walk", test_reader_walk);
 309   g_test_add_func ("/gvdb/reader/walk/big-endian", test_reader_walk_bigendian);
 310
 311   return g_test_run ();
 312 }