← Back to branch summary

~ubuntu-branches/ubuntu/quantal/maildir-utils/quantal

« back to all changes in this revision

Viewing changes to src/tests/test-mu-threads.c

  • Committer: Package Import Robot
  • Author(s): Norbert Preining
  • Date: 2012-03-15 08:45:56 UTC
  • mfrom: (1.2.5)
  • Revision ID: package-import@ubuntu.com-20120315084556-vqdvw8sgodo24aji
Tags: 0.9.8.2-1
http://bugs.debian.org/664001
http://bugs.debian.org/664006
* several new upstream versions
* b-d on libgmime-2.6-dev (Closes: #664001, #664006)
* bump standards version to 3.9.3, no changes necessary
* switch to source format 3.0 (quilt): debian/control, debian/rules
* maildir-utils depends on dpkg/install-info (lintian warning)
* fix man page lintian warnings

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/test-mu-threads.c
1
1
/* -*-mode: c; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-*/
2
2
 
3
 
/* 
 
3
/*
4
4
** Copyright (C) 2008-2011 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
5
5
**
6
6
** This program is free software; you can redistribute it and/or modify it
15
15
**
16
16
** You should have received a copy of the GNU General Public License
17
17
** along with this program; if not, write to the Free Software Foundation,
18
 
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  
19
 
**  
 
18
** Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
19
**
20
20
*/
21
21
 
22
22
#ifdef HAVE_CONFIG_H
38
38
fill_database (const char *testdir)
39
39
{
40
40
        gchar *cmdline, *tmpdir, *xpath;
41
 
        
 
41
 
42
42
        tmpdir = test_mu_common_get_random_tmpdir();
43
43
        cmdline = g_strdup_printf ("%s index --muhome=%s --maildir=%s"
44
44
                                   " --quiet",
45
45
                                   MU_PROGRAM, tmpdir, testdir);
46
46
        /* g_print ("%s\n", cmdline);  */
47
 
        
 
47
 
48
48
        g_assert (g_spawn_command_line_sync (cmdline, NULL, NULL,
49
49
                                             NULL, NULL));
50
50
        g_free (cmdline);
51
51
        xpath= g_strdup_printf ("%s%c%s", tmpdir,
52
52
                                G_DIR_SEPARATOR, "xapian");
53
53
        g_free (tmpdir);
54
 
        
 
54
 
55
55
        return xpath;
56
56
}
57
57
 
60
60
run_and_get_iter (const char *xpath, const char *query)
61
61
{
62
62
        MuQuery  *mquery;
 
63
        MuStore *store;
63
64
        MuMsgIter *iter;
64
 
                
65
 
        mquery = mu_query_new (xpath, NULL);
 
65
 
 
66
        store = mu_store_new_read_only (xpath, NULL);
 
67
        g_assert (store);
 
68
 
 
69
        mquery = mu_query_new (store, NULL);
 
70
        mu_store_unref (store);
66
71
        g_assert (query);
67
 
        
 
72
 
68
73
        iter = mu_query_run (mquery, query, TRUE, MU_MSG_FIELD_ID_DATE,
69
 
                             FALSE, NULL);
 
74
                             FALSE, -1, NULL);
70
75
        mu_query_destroy (mquery);
71
76
        g_assert (iter);
72
 
        
 
77
 
73
78
        return iter;
74
79
}
75
80
 
78
83
test_mu_threads_01 (void)
79
84
{
80
85
        gchar *xpath;
81
 
        MuMsgIter *iter;        
 
86
        MuMsgIter *iter;
82
87
        unsigned u;
83
 
        
 
88
 
84
89
        struct {
85
90
                const char* threadpath;
86
91
                const char *msgid;
99
104
 
100
105
                /* two children of absent root 4.0 */
101
106
                {"4:0", "child4.0@msg.id", "Re: child 4.0"},
102
 
                {"4:1", "child4.1@msg.id", "Re: child 4.1"}     
 
107
                {"4:1", "child4.1@msg.id", "Re: child 4.1"}
103
108
        };
104
 
        
 
109
 
105
110
        xpath = fill_database (MU_TESTMAILDIR3);
106
111
        g_assert (xpath != NULL);
107
 
        
 
112
 
108
113
        iter = run_and_get_iter (xpath, "abc");
109
114
        g_assert (iter);
110
115
        g_assert (!mu_msg_iter_is_done(iter));
113
118
        while (!mu_msg_iter_is_done (iter) && u < G_N_ELEMENTS(items)) {
114
119
                MuMsg *msg;
115
120
                const MuMsgIterThreadInfo *ti;
116
 
                
 
121
 
117
122
                ti = mu_msg_iter_get_thread_info (iter);
118
123
                if (!ti)
119
 
                        g_print ("%s: thread info not found\n",
120
 
                                 mu_msg_get_msgid(mu_msg_iter_get_msg (iter, NULL)));
121
 
 
 
124
                        g_print ("%s: thread info not found for %u\n",
 
125
                                 __FUNCTION__, (unsigned)mu_msg_iter_get_docid(iter));
122
126
                g_assert(ti);
123
 
                
124
 
                msg = mu_msg_iter_get_msg (iter, NULL);
 
127
 
 
128
                msg = mu_msg_iter_get_msg_floating (iter);
 
129
                g_assert (msg);
125
130
                /* g_print ("%s %s %s\n", ti->threadpath, */
126
131
                /*       mu_msg_get_msgid(msg), */
127
132
                /*       mu_msg_get_path (msg) */
128
133
                /*      ); */
129
 
                
 
134
 
130
135
                g_assert (u < G_N_ELEMENTS(items));
131
136
 
132
137
                g_assert_cmpstr (ti->threadpath,==,items[u].threadpath);
133
138
                g_assert_cmpstr (mu_msg_get_subject(msg),==,items[u].subject);
134
139
                g_assert_cmpstr (mu_msg_get_msgid(msg),==,items[u].msgid);
135
 
                
 
140
 
136
141
                ++u;
137
142
                mu_msg_iter_next (iter);
138
143
        }
139
144
        g_assert (u == G_N_ELEMENTS(items));
140
 
        
 
145
 
141
146
        g_free (xpath);
142
147
        mu_msg_iter_destroy (iter);
143
148
}
154
159
test_mu_threads_rogue (void)
155
160
{
156
161
        gchar *xpath;
157
 
        MuMsgIter *iter;        
 
162
        MuMsgIter *iter;
158
163
        unsigned u;
159
164
        tinfo *items;
160
165
 
178
183
        iter = run_and_get_iter (xpath, "def");
179
184
        g_assert (iter);
180
185
        g_assert (!mu_msg_iter_is_done(iter));
181
 
        
182
 
        /* due to the random order in files can be indexed, there are two possible ways 
 
186
 
 
187
        /* due to the random order in files can be indexed, there are two possible ways
183
188
         * for the threads to be built-up; both are okay */
184
 
        if (g_strcmp0 (mu_msg_get_msgid(mu_msg_iter_get_msg (iter, NULL)), 
 
189
        if (g_strcmp0 (mu_msg_get_msgid(mu_msg_iter_get_msg_floating (iter)),
185
190
                       "cycle0@msg.id") == 0)
186
191
                items = items1;
187
192
        else
191
196
        while (!mu_msg_iter_is_done (iter) && u < G_N_ELEMENTS(items1)) {
192
197
                MuMsg *msg;
193
198
                const MuMsgIterThreadInfo *ti;
194
 
                
 
199
 
195
200
                ti = mu_msg_iter_get_thread_info (iter);
196
201
                if (!ti)
197
202
                        g_print ("%s: thread info not found\n",
198
 
                                 mu_msg_get_msgid(mu_msg_iter_get_msg (iter, NULL)));
199
 
 
 
203
                                 mu_msg_get_msgid(mu_msg_iter_get_msg_floating (iter)));
200
204
                g_assert(ti);
201
 
                
202
 
                msg = mu_msg_iter_get_msg (iter, NULL);
 
205
 
 
206
                msg = mu_msg_iter_get_msg_floating (iter); /* don't unref */
203
207
                /* g_print ("%s %s %s\n", ti->threadpath, */
204
208
                /*       mu_msg_get_msgid(msg), */
205
209
                /*       mu_msg_get_path (msg) */
206
210
                /*      ); */
207
 
                
 
211
 
208
212
                g_assert (u < G_N_ELEMENTS(items1));
209
213
 
210
214
                g_assert_cmpstr (ti->threadpath,==,(items)[u].threadpath);
211
215
                g_assert_cmpstr (mu_msg_get_subject(msg),==,(items)[u].subject);
212
216
                g_assert_cmpstr (mu_msg_get_msgid(msg),==,(items)[u].msgid);
213
 
                
 
217
 
214
218
                ++u;
215
219
                mu_msg_iter_next (iter);
216
220
        }
217
221
        g_assert (u == G_N_ELEMENTS(items1));
218
 
        
 
222
 
219
223
        g_free (xpath);
220
224
        mu_msg_iter_destroy (iter);
221
225
}
226
230
main (int argc, char *argv[])
227
231
{
228
232
        int rv;
229
 
        
230
 
        g_test_init (&argc, &argv, NULL);       
 
233
 
 
234
        g_test_init (&argc, &argv, NULL);
231
235
 
232
236
        g_test_add_func ("/mu-query/test-mu-threads-01", test_mu_threads_01);
233
237
        g_test_add_func ("/mu-query/test-mu-threads-rogue", test_mu_threads_rogue);
234
 
        
235
 
        /* g_log_set_handler (NULL, */
236
 
        /*                 G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION, */
237
 
        /*                 (GLogFunc)black_hole, NULL); */
 
238
 
 
239
        g_log_set_handler (NULL,
 
240
                           G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION,
 
241
                           (GLogFunc)black_hole, NULL);
238
242
 
239
243
        rv = g_test_run ();
240
 
        
 
244
 
241
245
        return rv;
242
246
}
243