← Back to branch summary

~didrocks/ubuntuone-client/dont-suffer-zg-crash

« back to all changes in this revision

Viewing changes to libsyncdaemon/test-libsyncdaemon.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2010-06-23 23:08:15 UTC
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: james.westby@ubuntu.com-20100623230815-4m3ugh10u9x9xzw5
Tags: upstream-1.3.2
Import upstream version 1.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
libsyncdaemon/test-libsyncdaemon.c
19
19
 *
20
20
 */
21
21
 
22
 
#include "syncdaemon-daemon.h"
23
 
#include "syncdaemon-config-interface.h"
24
 
#include "syncdaemon-publicfiles-interface.h"
 
22
#include "libsyncdaemon.h"
 
23
 
 
24
#define TEST_PATH "/home/user/transfer.file"
 
25
#define TEST_ID   "abcdefeghijk"
 
26
#define TEST_HASH "1234567890abcdef"
25
27
 
26
28
static SyncdaemonDaemon *the_daemon = NULL;
27
29
 
32
34
        gchar *key, *value;
33
35
 
34
36
        g_hash_table_iter_init (&iter, hash);
35
 
        while (g_hash_table_iter_next (&iter, &key, &value))
36
 
                g_print ("\tKey %s -> %s", key, value);
37
 
 
38
 
        g_hash_table_iter_remove (&iter);
 
37
        while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value))
 
38
                g_print ("\tKey %s -> %s\n", key, value);
39
39
}
40
40
 
41
41
static void
84
84
}
85
85
 
86
86
static void
 
87
test_folder_info (void)
 
88
{
 
89
        GHashTable *hash;
 
90
        SyncdaemonFolderInfo *finfo;
 
91
 
 
92
        /* Test creating an empty SyncdaemonFolderInfo */
 
93
        finfo = syncdaemon_folder_info_new ();
 
94
        g_assert (SYNCDAEMON_IS_FOLDER_INFO (finfo));
 
95
 
 
96
        syncdaemon_folder_info_set_path (finfo, TEST_PATH);
 
97
        g_assert (g_strcmp0 (syncdaemon_folder_info_get_path (finfo), TEST_PATH) == 0);
 
98
        syncdaemon_folder_info_set_volume_id (finfo, TEST_ID);
 
99
        g_assert (g_strcmp0 (syncdaemon_folder_info_get_volume_id (finfo), TEST_ID) == 0);
 
100
        syncdaemon_folder_info_set_subscribed (finfo, TRUE);
 
101
        g_assert (syncdaemon_folder_info_get_subscribed (finfo));
 
102
 
 
103
        g_object_unref (G_OBJECT (finfo));
 
104
 
 
105
        /* Test creating a SyncdaemonFolderInfo from a hash table */
 
106
        hash = g_hash_table_new (g_str_hash, g_str_equal);
 
107
        g_hash_table_insert (hash, "path", TEST_PATH);
 
108
        g_hash_table_insert (hash, "subscribed", "True");
 
109
        g_hash_table_insert (hash, "volume_id", TEST_ID);
 
110
 
 
111
        finfo = syncdaemon_folder_info_new_from_hash_table (hash);
 
112
        g_assert (g_strcmp0 (syncdaemon_folder_info_get_path (finfo), TEST_PATH) == 0);
 
113
        g_assert (g_strcmp0 (syncdaemon_folder_info_get_volume_id (finfo), TEST_ID) == 0);
 
114
        g_assert (syncdaemon_folder_info_get_subscribed (finfo));
 
115
 
 
116
        g_object_unref (G_OBJECT (finfo));
 
117
        g_hash_table_destroy (hash);
 
118
}
 
119
 
 
120
static void
 
121
test_folders (void)
 
122
{
 
123
        GSList *folders_list, *l;
 
124
        SyncdaemonFoldersInterface *folders;
 
125
 
 
126
        folders = (SyncdaemonFoldersInterface *) syncdaemon_daemon_get_folders_interface (the_daemon);
 
127
        g_assert (SYNCDAEMON_IS_FOLDERS_INTERFACE (folders));
 
128
 
 
129
        /* Get list of UDFs */
 
130
        folders_list = syncdaemon_folders_interface_get_folders (folders);
 
131
        g_assert (g_slist_length (folders_list) >= 1);
 
132
        
 
133
        for (l = folders_list; l != NULL; l = l->next) {
 
134
                SyncdaemonFolderInfo *folder_info = (SyncdaemonFolderInfo *) l->data;
 
135
 
 
136
                g_assert (SYNCDAEMON_IS_FOLDER_INFO (folder_info));
 
137
                g_print ("\tPath -> %s\n", syncdaemon_folder_info_get_path (folder_info));
 
138
                g_print ("\tVolume ID -> %s\n", syncdaemon_folder_info_get_volume_id (folder_info));
 
139
        }
 
140
 
 
141
        g_slist_free (folders_list);
 
142
}
 
143
 
 
144
static void
 
145
test_metadata (void)
 
146
{
 
147
        GHashTable *hash;
 
148
        SyncdaemonMetadata *metadata;
 
149
 
 
150
        /* Test creating an empty SyncdaemonMetadata */
 
151
        metadata = syncdaemon_metadata_new ();
 
152
        g_assert (SYNCDAEMON_IS_METADATA (metadata));
 
153
 
 
154
        syncdaemon_metadata_set_path (metadata, TEST_PATH);
 
155
        g_assert (g_strcmp0 (syncdaemon_metadata_get_path (metadata), TEST_PATH) == 0);
 
156
 
 
157
        syncdaemon_metadata_set_local_hash (metadata, TEST_HASH);
 
158
        g_assert (g_strcmp0 (syncdaemon_metadata_get_local_hash (metadata), TEST_HASH) == 0);
 
159
 
 
160
        syncdaemon_metadata_set_server_hash (metadata, TEST_HASH);
 
161
        g_assert (g_strcmp0 (syncdaemon_metadata_get_server_hash (metadata), TEST_HASH) == 0);
 
162
 
 
163
        syncdaemon_metadata_set_share_id (metadata, TEST_ID);
 
164
        g_assert (g_strcmp0 (syncdaemon_metadata_get_share_id (metadata), TEST_ID) == 0);
 
165
 
 
166
        syncdaemon_metadata_set_node_id (metadata, TEST_ID);
 
167
        g_assert (g_strcmp0 (syncdaemon_metadata_get_node_id (metadata), TEST_ID) == 0);
 
168
 
 
169
        g_object_unref (G_OBJECT (metadata));
 
170
 
 
171
        /* Test creating a SyncdaemonMetadata from a hash table */
 
172
        hash = g_hash_table_new (g_str_hash, g_str_equal);
 
173
        g_hash_table_insert (hash, "path", TEST_PATH);
 
174
        g_hash_table_insert (hash, "local_hash", TEST_HASH);
 
175
        g_hash_table_insert (hash, "server_hash", TEST_HASH);
 
176
        g_hash_table_insert (hash, "share_id", TEST_ID);
 
177
        g_hash_table_insert (hash, "node_id", TEST_ID);
 
178
 
 
179
        metadata = syncdaemon_metadata_new_from_hash_table (hash);
 
180
        g_assert (SYNCDAEMON_IS_METADATA (metadata));
 
181
        g_assert (g_strcmp0 (syncdaemon_metadata_get_path (metadata), TEST_PATH) == 0);
 
182
        g_assert (g_strcmp0 (syncdaemon_metadata_get_local_hash (metadata), TEST_HASH) == 0);
 
183
        g_assert (g_strcmp0 (syncdaemon_metadata_get_server_hash (metadata), TEST_HASH) == 0);
 
184
        g_assert (g_strcmp0 (syncdaemon_metadata_get_share_id (metadata), TEST_ID) == 0);
 
185
        g_assert (g_strcmp0 (syncdaemon_metadata_get_node_id (metadata), TEST_ID) == 0);
 
186
 
 
187
        g_object_unref (G_OBJECT (metadata));
 
188
        g_hash_table_destroy (hash);
 
189
}
 
190
 
 
191
static void
87
192
test_public_files (void)
88
193
{
89
 
        SyncdaemonPublicfilesInterface *public = syncdaemon_daemon_get_publicfiles_interface (the_daemon);
 
194
        SyncdaemonPublicfilesInterface *public;
 
195
 
 
196
        public = (SyncdaemonPublicfilesInterface *) syncdaemon_daemon_get_publicfiles_interface (the_daemon);
90
197
        g_assert (SYNCDAEMON_IS_PUBLICFILES_INTERFACE (public));
91
198
}
92
199
 
93
200
static void
 
201
test_status (void)
 
202
{
 
203
        GSList *list;
 
204
        SyncdaemonStatusInterface *status;
 
205
 
 
206
        status = (SyncdaemonStatusInterface *) syncdaemon_daemon_get_status_interface (the_daemon);
 
207
        g_assert (SYNCDAEMON_IS_STATUS_INTERFACE (status));
 
208
 
 
209
        /* Test getting current downloads */
 
210
        list = syncdaemon_status_interface_get_current_downloads (status);
 
211
        while (list != NULL) {
 
212
                SyncdaemonTransferInfo *tinfo = (SyncdaemonTransferInfo *) list->data;
 
213
 
 
214
                g_assert (SYNCDAEMON_IS_TRANSFER_INFO (tinfo));
 
215
                list = g_slist_remove (list, tinfo);
 
216
        }
 
217
 
 
218
        /* Test getting current uploads */
 
219
        list = syncdaemon_status_interface_get_current_uploads (status);
 
220
        while (list != NULL) {
 
221
                SyncdaemonTransferInfo *tinfo = (SyncdaemonTransferInfo *) list->data;
 
222
 
 
223
                g_assert (SYNCDAEMON_IS_TRANSFER_INFO (tinfo));
 
224
                list = g_slist_remove (list, tinfo);
 
225
        }
 
226
}
 
227
 
 
228
static void
 
229
test_transfer_info (void)
 
230
{
 
231
        GHashTable *hash;
 
232
        SyncdaemonTransferInfo *tinfo;
 
233
 
 
234
        /* Test creating an empty SyncdaemonTransferInfo */
 
235
        tinfo = syncdaemon_transfer_info_new (TEST_PATH);
 
236
        g_assert (SYNCDAEMON_IS_TRANSFER_INFO (tinfo));
 
237
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_path (tinfo), TEST_PATH) == 0);
 
238
 
 
239
        syncdaemon_transfer_info_set_share_id (tinfo, TEST_ID);
 
240
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_share_id (tinfo), TEST_ID) == 0);
 
241
 
 
242
        syncdaemon_transfer_info_set_node_id (tinfo, TEST_ID);
 
243
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_node_id (tinfo), TEST_ID) == 0);
 
244
 
 
245
        syncdaemon_transfer_info_set_bytes_transferred (tinfo, 100);
 
246
        g_assert (syncdaemon_transfer_info_get_bytes_transferred (tinfo) == 100);
 
247
 
 
248
        syncdaemon_transfer_info_set_total_size (tinfo, 1000);
 
249
        g_assert (syncdaemon_transfer_info_get_total_size (tinfo) == 1000);
 
250
 
 
251
        g_object_unref (G_OBJECT (tinfo));
 
252
 
 
253
        /* Test creating a SyncdaemonTransferInfo from a hash table */
 
254
        hash = g_hash_table_new (g_str_hash, g_str_equal);
 
255
        g_hash_table_insert (hash, "path", TEST_PATH);
 
256
        g_hash_table_insert (hash, "share_id", TEST_ID);
 
257
        g_hash_table_insert (hash, "node_id", TEST_ID);
 
258
        g_hash_table_insert (hash, "n_bytes_read", "100");
 
259
        g_hash_table_insert (hash, "deflated_size", "1000");
 
260
 
 
261
        tinfo = syncdaemon_transfer_info_new_from_hash_table (hash);
 
262
        g_assert (SYNCDAEMON_IS_TRANSFER_INFO (tinfo));
 
263
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_path (tinfo), TEST_PATH) == 0);
 
264
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_share_id (tinfo), TEST_ID) == 0);
 
265
        g_assert (g_strcmp0 (syncdaemon_transfer_info_get_node_id (tinfo), TEST_ID) == 0);
 
266
        g_assert (syncdaemon_transfer_info_get_bytes_transferred (tinfo) == 100);
 
267
        g_assert (syncdaemon_transfer_info_get_total_size (tinfo) == 1000);
 
268
 
 
269
        g_object_unref (G_OBJECT (tinfo));
 
270
        g_hash_table_destroy (hash);
 
271
}
 
272
 
 
273
static void
94
274
daemon_connected_cb (SyncdaemonDaemon *daemon, gpointer user_data)
95
275
{
96
276
        g_debug ("Daemon is now connected, and root_dir = ", syncdaemon_daemon_get_root_dir (the_daemon));
137
317
        /* Add test functions */
138
318
        g_test_add_func ("/testlibsyncdaemon/TestDaemon", test_daemon);
139
319
        g_test_add_func ("/testlibsyncdaemon/TestConfig", test_config);
 
320
        g_test_add_func ("/testlibsyncdaemon/TestFolderInfo", test_folder_info);
 
321
        g_test_add_func ("/testlibsyncdaemon/TestFolders", test_folders);
 
322
        g_test_add_func ("/testlibsyncdaemon/TestMetadata", test_metadata);
140
323
        g_test_add_func ("/testlibsyncdaemon/TestPublicFiles", test_public_files);
 
324
        g_test_add_func ("/testlibsyncdaemon/TestStatus", test_status);
 
325
        g_test_add_func ("/testlibsyncdaemon/TestTransferInfo", test_transfer_info);
141
326
 
142
327
        /* Run main loop and tests suite */
143
 
        main_loop = g_main_loop_new (NULL, TRUE);
 
328
        //main_loop = g_main_loop_new (NULL, TRUE);
144
329
        return g_test_run ();
145
330
}