1 /* GLib testing framework examples and tests
2 * Authors: Jesse van den Kieboom <jessevdk@gnome.org>
3 *
4 * This work is provided "as is"; redistribution and modification
5 * in whole or in part, in any medium, physical or electronic is
6 * permitted without restriction.
7 *
8 * This work is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * In no event shall the authors or contributors be liable for any
13 * direct, indirect, incidental, special, exemplary, or consequential
14 * damages (including, but not limited to, procurement of substitute
15 * goods or services; loss of use, data, or profits; or business
16 * interruption) however caused and on any theory of liability, whether
17 * in contract, strict liability, or tort (including negligence or
18 * otherwise) arising in any way out of the use of this software, even
19 * if advised of the possibility of such damage.
20 */
21
22 #include <glib/glib.h>
23 #include <gio/gio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #define DATA_TO_WRITE "Hello world\n"
28
29 typedef struct
30 {
31 GOutputStream *conv_stream;
32 GOutputStream *data_stream;
33 gchar *expected_output;
34 gsize expected_size;
35 GMainLoop *main_loop;
36 } SetupData;
37
38 static void
create_streams(SetupData * data)39 create_streams (SetupData *data)
40 {
41 GConverter *converter;
42
43 converter = G_CONVERTER (g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP, -1));
44
45 data->data_stream = g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
46 data->conv_stream = g_converter_output_stream_new (data->data_stream,
47 converter);
48
49 g_object_unref (converter);
50 }
51
52 static void
destroy_streams(SetupData * data)53 destroy_streams (SetupData *data)
54 {
55 g_object_unref (data->data_stream);
56 g_object_unref (data->conv_stream);
57 }
58
59 static void
write_data_to_stream(SetupData * data)60 write_data_to_stream (SetupData *data)
61 {
62 gsize bytes_written;
63 GError *error = NULL;
64
65 /* just write the data synchronously */
66 g_output_stream_write_all (data->conv_stream,
67 DATA_TO_WRITE,
68 sizeof (DATA_TO_WRITE),
69 &bytes_written,
70 NULL,
71 &error);
72
73 g_assert_no_error (error);
74 g_assert_cmpint (sizeof (DATA_TO_WRITE), ==, bytes_written);
75 }
76
77 static void
setup_data(SetupData * data,gconstpointer user_data)78 setup_data (SetupData *data,
79 gconstpointer user_data)
80 {
81 data->main_loop = g_main_loop_new (NULL, FALSE);
82 create_streams (data);
83 }
84
85 static void
teardown_data(SetupData * data,gconstpointer user_data)86 teardown_data (SetupData *data,
87 gconstpointer user_data)
88 {
89 /* cleanup */
90 g_main_loop_unref (data->main_loop);
91
92 destroy_streams (data);
93
94 g_free (data->expected_output);
95 }
96
97 static void
compare_output(SetupData * data)98 compare_output (SetupData *data)
99 {
100 gsize size;
101 gpointer written;
102
103 written = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (data->data_stream));
104 size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (data->data_stream));
105
106 g_assert_cmpmem (written, size, data->expected_output, data->expected_size);
107 }
108
109 static void
async_close_ready(GOutputStream * stream,GAsyncResult * result,SetupData * data)110 async_close_ready (GOutputStream *stream,
111 GAsyncResult *result,
112 SetupData *data)
113 {
114 GError *error = NULL;
115
116 /* finish the close */
117 g_output_stream_close_finish (stream, result, &error);
118
119 g_assert_no_error (error);
120
121 /* compare the output with the desired output */
122 compare_output (data);
123
124 g_main_loop_quit (data->main_loop);
125 }
126
127 static void
prepare_data(SetupData * data,gboolean manual_flush)128 prepare_data (SetupData *data,
129 gboolean manual_flush)
130 {
131 GError *error = NULL;
132 gpointer written;
133
134 write_data_to_stream (data);
135
136 if (manual_flush)
137 {
138 g_output_stream_flush (data->conv_stream, NULL, &error);
139 g_assert_no_error (error);
140 }
141
142 g_output_stream_close (data->conv_stream, NULL, &error);
143
144 g_assert_no_error (error);
145
146 written = g_memory_output_stream_get_data (G_MEMORY_OUTPUT_STREAM (data->data_stream));
147
148 data->expected_size = g_memory_output_stream_get_data_size (G_MEMORY_OUTPUT_STREAM (data->data_stream));
149
150 g_assert_cmpuint (data->expected_size, >, 0);
151
152 data->expected_output = g_memdup2 (written, data->expected_size);
153
154 /* then recreate the streams and prepare them for the asynchronous close */
155 destroy_streams (data);
156 create_streams (data);
157
158 write_data_to_stream (data);
159 }
160
161 static void
test_without_flush(SetupData * data,gconstpointer user_data)162 test_without_flush (SetupData *data,
163 gconstpointer user_data)
164 {
165 prepare_data (data, FALSE);
166
167 g_test_bug ("617937");
168
169 /* just close asynchronously */
170 g_output_stream_close_async (data->conv_stream,
171 G_PRIORITY_DEFAULT,
172 NULL,
173 (GAsyncReadyCallback)async_close_ready,
174 data);
175
176 g_main_loop_run (data->main_loop);
177 }
178
179 static void
test_with_flush(SetupData * data,gconstpointer user_data)180 test_with_flush (SetupData *data, gconstpointer user_data)
181 {
182 GError *error = NULL;
183
184 g_test_bug ("617937");
185
186 prepare_data (data, TRUE);
187
188 g_output_stream_flush (data->conv_stream, NULL, &error);
189
190 g_assert_no_error (error);
191
192 /* then close asynchronously */
193 g_output_stream_close_async (data->conv_stream,
194 G_PRIORITY_DEFAULT,
195 NULL,
196 (GAsyncReadyCallback)async_close_ready,
197 data);
198
199 g_main_loop_run (data->main_loop);
200 }
201
202 static void
async_flush_ready(GOutputStream * stream,GAsyncResult * result,SetupData * data)203 async_flush_ready (GOutputStream *stream,
204 GAsyncResult *result,
205 SetupData *data)
206 {
207 GError *error = NULL;
208
209 g_output_stream_flush_finish (stream, result, &error);
210
211 g_assert_no_error (error);
212
213 /* then close async after the flush */
214 g_output_stream_close_async (data->conv_stream,
215 G_PRIORITY_DEFAULT,
216 NULL,
217 (GAsyncReadyCallback)async_close_ready,
218 data);
219 }
220
221 static void
test_with_async_flush(SetupData * data,gconstpointer user_data)222 test_with_async_flush (SetupData *data,
223 gconstpointer user_data)
224 {
225 g_test_bug ("617937");
226
227 prepare_data (data, TRUE);
228
229 /* first flush async */
230 g_output_stream_flush_async (data->conv_stream,
231 G_PRIORITY_DEFAULT,
232 NULL,
233 (GAsyncReadyCallback)async_flush_ready,
234 data);
235
236 g_main_loop_run (data->main_loop);
237 }
238
239 int
main(int argc,char * argv[])240 main (int argc,
241 char *argv[])
242 {
243 SetupData *data;
244
245 g_test_init (&argc, &argv, NULL);
246
247 g_test_bug_base ("http://bugzilla.gnome.org/");
248
249 data = g_slice_new (SetupData);
250
251 /* test closing asynchronously without flushing manually */
252 g_test_add ("/close-async/without-flush",
253 SetupData,
254 data,
255 setup_data,
256 test_without_flush,
257 teardown_data);
258
259 /* test closing asynchronously with a synchronous manually flush */
260 g_test_add ("/close-async/with-flush",
261 SetupData,
262 data,
263 setup_data,
264 test_with_flush,
265 teardown_data);
266
267 /* test closing asynchronously with an asynchronous manually flush */
268 g_test_add ("/close-async/with-async-flush",
269 SetupData,
270 data,
271 setup_data,
272 test_with_async_flush,
273 teardown_data);
274
275 g_slice_free (SetupData, data);
276
277 return g_test_run();
278 }
279