libsecret/test-value.c

   1 /* libsecret - GLib wrapper for Secret Service
   2  *
   3  * Copyright 2012 Red Hat Inc.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public License as published
   7  * by the Free Software Foundation; either version 2 of the licence or (at
   8  * your option) any later version.
   9  *
  10  * See the included COPYING file for more information.
  11  */
  12
  13
  14 #include "config.h"
  15
  16 #include "secret-value.h"
  17 #include "secret-private.h"
  18
  19 #include "egg/egg-testing.h"
  20 #include "egg/egg-secure-memory.h"
  21
  22 #include <glib.h>
  23
  24 #include <errno.h>
  25 #include <stdlib.h>
  26
  27 EGG_SECURE_DECLARE (test_value);
  28
  29 static void
  30 test_new (void)
  31 {
  32         SecretValue *value;
  33         gsize length;
  34
  35         value = secret_value_new ("blahblah", 4, "text/plain");
  36
  37         g_assert_cmpstr (secret_value_get (value, &length), ==, "blah");
  38         g_assert_cmpuint (length, ==, 4);
  39
  40         g_assert_cmpstr (secret_value_get_content_type (value), ==, "text/plain");
  41
  42         secret_value_unref (value);
  43 }
  44
  45 static void
  46 test_new_terminated (void)
  47 {
  48         SecretValue *value;
  49         gsize length;
  50
  51         value = secret_value_new ("blah", -1, "text/plain");
  52
  53         g_assert_cmpstr (secret_value_get (value, &length), ==, "blah");
  54         g_assert_cmpuint (length, ==, 4);
  55
  56         g_assert_cmpstr (secret_value_get_content_type (value), ==, "text/plain");
  57
  58         secret_value_unref (value);
  59 }
  60
  61 static void
  62 test_new_full (void)
  63 {
  64         SecretValue *value;
  65         gchar *data = g_strdup ("blah");
  66         gsize length;
  67
  68         value = secret_value_new_full (data, 4, "text/plain", g_free);
  69
  70         g_assert_cmpstr (secret_value_get (value, &length), ==, "blah");
  71         g_assert_cmpuint (length, ==, 4);
  72
  73         /* No copy done here */
  74         g_assert (secret_value_get (value, NULL) == data);
  75
  76         secret_value_unref (value);
  77 }
  78
  79 static void
  80 test_new_full_terminated (void)
  81 {
  82         SecretValue *value;
  83         gchar *data = g_strdup ("blah");
  84         gsize length;
  85
  86         value = secret_value_new_full (data, -1, "text/plain", g_free);
  87
  88         g_assert_cmpstr (secret_value_get (value, &length), ==, "blah");
  89         g_assert_cmpuint (length, ==, 4);
  90
  91         /* No copy done here */
  92         g_assert (secret_value_get (value, NULL) == data);
  93
  94         secret_value_unref (value);
  95 }
  96
  97 static void
  98 test_new_empty (void)
  99 {
 100         SecretValue *value;
 101         const gchar *password;
 102         gsize length;
 103
 104         value = secret_value_new (NULL, 0, "text/plain");
 105         g_assert (value != NULL);
 106         password = secret_value_get (value, &length);
 107         g_assert_cmpuint (length, ==, 0);
 108         g_assert_cmpstr (password, ==, "");
 109         secret_value_unref (value);
 110
 111         value = secret_value_new ("", 0, "text/plain");
 112         g_assert (value != NULL);
 113         password = secret_value_get (value, &length);
 114         g_assert_cmpuint (length, ==, 0);
 115         g_assert_cmpstr (password, ==, "");
 116         secret_value_unref (value);
 117 }
 118
 119 static void
 120 test_ref_unref (void)
 121 {
 122         SecretValue *value;
 123         SecretValue *value2;
 124         gsize length;
 125
 126         value = secret_value_new ("blah", 4, "text/plain");
 127         value2 = secret_value_ref(value);
 128         secret_value_unref (value);
 129
 130         g_assert_cmpstr (secret_value_get (value2, &length), ==, "blah");
 131         g_assert_cmpuint (length, ==, 4);
 132
 133         secret_value_unref (value2);
 134 }
 135
 136 static void
 137 test_boxed (void)
 138 {
 139         SecretValue *value;
 140         SecretValue *value2;
 141         gsize length;
 142
 143         value = secret_value_new ("blah", 4, "text/plain");
 144         value2 = g_boxed_copy (SECRET_TYPE_VALUE, value);
 145         g_boxed_free (SECRET_TYPE_VALUE, value);
 146
 147         g_assert_cmpstr (secret_value_get (value2, &length), ==, "blah");
 148         g_assert_cmpuint (length, ==, 4);
 149
 150         g_boxed_free (SECRET_TYPE_VALUE, value2);
 151 }
 152
 153 static void
 154 test_to_password (void)
 155 {
 156         SecretValue *value;
 157         gchar *password;
 158
 159         value = secret_value_new_full (egg_secure_strdup ("blah"), -1,
 160                                         "text/plain", egg_secure_free);
 161
 162         password = _secret_value_unref_to_password (value);
 163         g_assert_cmpstr (password, ==, "blah");
 164
 165         egg_secure_free (password);
 166 }
 167
 168 static void
 169 test_to_password_bad_destroy (void)
 170 {
 171         SecretValue *value;
 172         gchar *password;
 173
 174         value = secret_value_new_full (g_strdup ("blah"), -1,
 175                                         "text/plain", g_free);
 176
 177         password = _secret_value_unref_to_password (value);
 178         g_assert_cmpstr (password, ==, "blah");
 179
 180         egg_secure_free (password);
 181 }
 182
 183 static void
 184 test_to_password_bad_content (void)
 185 {
 186         SecretValue *value;
 187         gchar *password;
 188
 189         value = secret_value_new_full (g_strdup ("w\xFFooowhee"), -1,
 190                                         "application/octet-stream", g_free);
 191
 192         password = _secret_value_unref_to_password (value);
 193         g_assert_cmpstr (password, ==, NULL);
 194 }
 195
 196 static void
 197 test_to_password_extra_ref (void)
 198 {
 199         SecretValue *value;
 200         gchar *password;
 201
 202         value = secret_value_new_full (egg_secure_strdup ("blah"), -1,
 203                                         "text/plain", egg_secure_free);
 204         secret_value_ref (value);
 205
 206         password = _secret_value_unref_to_password (value);
 207         g_assert_cmpstr (password, ==, "blah");
 208
 209         egg_secure_free (password);
 210         secret_value_unref (value);
 211 }
 212
 213 int
 214 main (int argc, char **argv)
 215 {
 216         g_test_init (&argc, &argv, NULL);
 217         g_set_prgname ("test-value");
 218
 219 #if !GLIB_CHECK_VERSION(2,35,0)
 220         g_type_init ();
 221 #endif
 222
 223         g_test_add_func ("/value/new", test_new);
 224         g_test_add_func ("/value/new-terminated", test_new_terminated);
 225         g_test_add_func ("/value/new-full", test_new_full);
 226         g_test_add_func ("/value/new-full-terminated", test_new_full_terminated);
 227         g_test_add_func ("/value/new-empty", test_new_empty);
 228         g_test_add_func ("/value/ref-unref", test_ref_unref);
 229         g_test_add_func ("/value/boxed", test_boxed);
 230         g_test_add_func ("/value/to-password", test_to_password);
 231         g_test_add_func ("/value/to-password-bad-destroy", test_to_password_bad_destroy);
 232         g_test_add_func ("/value/to-password-bad-content", test_to_password_bad_content);
 233         g_test_add_func ("/value/to-password-extra-ref", test_to_password_extra_ref);
 234
 235         return egg_tests_run_with_loop ();
 236 }