Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
grn-assertions.c
Go to the documentation of this file.
1 /* -*- c-basic-offset: 2; coding: utf-8 -*- */
2 /*
3  Copyright (C) 2008-2012 Kouhei Sutou <kou@clear-code.com>
4 
5  This library is free software; you can redistribute it and/or
6  modify it under the terms of the GNU Lesser General Public
7  License version 2.1 as published by the Free Software Foundation.
8 
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13 
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 #include <cutter/cut-helper.h>
20 #include <gcutter.h>
21 
22 #include <groonga_in.h>
23 #include <db.h>
24 #include <util.h>
25 #include <str.h>
26 
27 #include "grn-assertions.h"
28 
29 void
30 grn_test_assert_helper(grn_rc rc, const gchar *expression)
31 {
32  if (rc == GRN_SUCCESS) {
33  cut_test_pass();
34  } else {
35  cut_test_fail(cut_take_printf("expected: <%s> == grn_success\n"
36  " but was: <%s>",
37  expression,
38  grn_rc_to_string(rc)));
39  }
40 }
41 
42 void
43 grn_test_assert_equal_rc_helper(grn_rc expected, grn_rc actual,
44  const gchar *expression_expected,
45  const gchar *expression_actual)
46 {
47  if (expected == actual) {
48  cut_test_pass();
49  } else {
50  cut_test_fail(cut_take_printf("<%s> == <%s>\n"
51  "expected: <%s>\n"
52  " but was: <%s>",
53  expression_expected,
54  expression_actual,
55  grn_rc_to_string(expected),
56  grn_rc_to_string(actual)));
57  }
58 }
59 
60 void
61 grn_test_assert_equal_id_helper(grn_ctx *context,
62  grn_id expected, grn_id actual,
63  const gchar *expression_context,
64  const gchar *expression_expected,
65  const gchar *expression_actual)
66 {
67  if (expected == actual) {
68  cut_test_pass();
69  } else {
70  grn_obj *expected_object, *actual_object;
71  grn_obj inspected_expected_object, inspected_actual_object;
72 
73  expected_object = grn_ctx_at(context, expected);
74  actual_object = grn_ctx_at(context, actual);
75  GRN_TEXT_INIT(&inspected_expected_object, 0);
76  GRN_TEXT_INIT(&inspected_actual_object, 0);
77  grn_inspect(context, &inspected_expected_object, expected_object);
78  grn_inspect(context, &inspected_actual_object, actual_object);
79  cut_set_expected(
80  cut_take_printf("%d: <%.*s>",
81  expected,
82  (int)GRN_TEXT_LEN(&inspected_expected_object),
83  GRN_TEXT_VALUE(&inspected_expected_object)));
84  cut_set_actual(
85  cut_take_printf("%d: <%.*s>",
86  actual,
87  (int)GRN_TEXT_LEN(&inspected_actual_object),
88  GRN_TEXT_VALUE(&inspected_actual_object)));
89  grn_obj_unlink(context, &inspected_expected_object);
90  grn_obj_unlink(context, &inspected_actual_object);
91  grn_obj_unlink(context, expected_object);
92  grn_obj_unlink(context, actual_object);
93  cut_test_fail(cut_take_printf("<%s> == <%s> (%s)\n"
94  " context: <%p>",
95  expression_expected,
96  expression_actual,
97  expression_context,
98  context));
99  }
100 }
101 
102 void
103 grn_test_assert_equal_type_helper(grn_ctx *context,
104  unsigned char expected,
105  unsigned char actual,
106  const gchar *expression_context,
107  const gchar *expression_expected,
108  const gchar *expression_actual)
109 {
110  if (expected == actual) {
111  cut_test_pass();
112  } else {
113  grn_obj inspected_expected, inspected_actual;
114 
115  GRN_TEXT_INIT(&inspected_expected, 0);
116  GRN_TEXT_INIT(&inspected_actual, 0);
117  grn_inspect_type(context, &inspected_expected, expected);
118  grn_inspect_type(context, &inspected_actual, actual);
119  cut_set_expected(
120  cut_take_printf("%x: <%.*s>",
121  expected,
122  (int)GRN_TEXT_LEN(&inspected_expected),
123  GRN_TEXT_VALUE(&inspected_expected)));
124  cut_set_actual(
125  cut_take_printf("%x: <%.*s>",
126  actual,
127  (int)GRN_TEXT_LEN(&inspected_actual),
128  GRN_TEXT_VALUE(&inspected_actual)));
129  grn_obj_unlink(context, &inspected_expected);
130  grn_obj_unlink(context, &inspected_actual);
131  cut_test_fail(cut_take_printf("<%s> == <%s> (%s)\n"
132  " context: <%p>",
133  expression_expected,
134  expression_actual,
135  expression_context,
136  context));
137  }
138 }
139 
140 void
141 grn_test_assert_equal_record_id_helper(grn_ctx *context, grn_obj *table,
142  grn_id expected, grn_id actual,
143  const gchar *expression_context,
144  const gchar *expression_table,
145  const gchar *expression_expected,
146  const gchar *expression_actual)
147 {
148  if (expected == actual) {
149  cut_test_pass();
150  } else {
151  gchar key[GRN_TABLE_MAX_KEY_SIZE];
152  int key_size;
153  const gchar *message;
154  grn_obj inspected_table;
155 
156  key_size = grn_table_get_key(context, table, expected, key, sizeof(key));
157  cut_set_expected(cut_take_printf("%d: <%.*s>", expected, key_size, key));
158  key_size = grn_table_get_key(context, table, actual, key, sizeof(key));
159  cut_set_actual(cut_take_printf("%d: <%.*s>", actual, key_size, key));
160 
161  GRN_TEXT_INIT(&inspected_table, 0);
162  grn_inspect(context, &inspected_table, table);
163  message = cut_take_printf("<%s> == <%s> (context: <%s>, table: <%s>)\n"
164  " context: <%p>\n"
165  " table: <%.*s>",
166  expression_expected,
167  expression_actual,
168  expression_context,
169  expression_table,
170  context,
171  (int)GRN_TEXT_LEN(&inspected_table),
172  GRN_TEXT_VALUE(&inspected_table));
173  grn_obj_unlink(context, &inspected_table);
174  cut_test_fail(message);
175  }
176 }
177 
178 void
179 grn_test_assert_nil_helper(grn_id id, const gchar *expression)
180 {
181  if (id == GRN_ID_NIL) {
182  cut_test_pass();
183  } else {
184  cut_test_fail(cut_take_printf("<%s> == <GRN_ID_NIL>\n"
185  "expected: <%u>\n"
186  " but was: <%u>",
187  expression,
188  GRN_ID_NIL, id));
189  }
190 }
191 
192 void
193 grn_test_assert_not_nil_helper(grn_id id, const gchar *expression)
194 {
195  if (id != GRN_ID_NIL) {
196  cut_test_pass();
197  } else {
198  cut_test_fail(cut_take_printf("<%s> != <GRN_ID_NIL>\n"
199  "expected: <%u> is not <%u>",
200  expression, id, GRN_ID_NIL));
201  }
202 }
203 
204 void
205 grn_test_assert_context_helper (grn_ctx *context, const gchar *expression)
206 {
207  if (!context) {
208  cut_test_with_user_message(
209  cut_assert_null_helper(context, expression),
210  cut_message("context should not NULL"));
211  } else if (context->rc == GRN_SUCCESS) {
212  cut_test_pass();
213  } else {
214  cut_test_fail(cut_take_printf("<(%s)->rc> != <GRN_SUCCESS>\n"
215  "expected: <%s> is <%s>\n"
216  "%s:%d: %s(): %s",
217  expression,
218  grn_rc_to_string(context->rc),
219  grn_rc_to_string(GRN_SUCCESS),
220  context->errfile, context->errline,
221  context->errfunc, context->errbuf));
222  }
223 }
224 
225 void
226 grn_test_assert_error_helper (grn_rc expected_rc, const gchar *expected_message,
227  grn_ctx *context, const gchar *expression)
228 {
229  if (!context) {
230  cut_test_with_user_message(
231  cut_assert_null_helper(context, expression),
232  cut_message("context should not NULL"));
233  } else if (context->rc == expected_rc &&
234  cut_equal_string(expected_message, context->errbuf)) {
235  cut_test_pass();
236  } else {
237  cut_test_fail(cut_take_printf("<%s>\n"
238  "expected: <%s>(%s)\n"
239  " actual: <%s>(%s)\n"
240  "%s:%d: %s():",
241  expression,
242  expected_message,
243  grn_rc_to_string(expected_rc),
244  context->errbuf,
245  grn_rc_to_string(context->rc),
246  context->errfile, context->errline,
247  context->errfunc));
248  }
249 }
250 
251 void
252 grn_test_assert_null_helper (grn_ctx *context,
253  grn_obj *object, const gchar *expression)
254 {
255  if (!object) {
256  cut_test_pass();
257  } else {
258  GString *inspected;
259  const gchar *taken_inspected;
260 
261  inspected = g_string_new(NULL);
262  grn_test_object_inspect(inspected, context, object);
263  taken_inspected = cut_take_string(inspected->str);
264  cut_test_fail(cut_take_printf("expected: <%s> is NULL\n"
265  " actual: <%s>",
266  expression,
267  taken_inspected));
268  }
269 }
270 
271 void
272 grn_test_assert_not_null_helper (grn_ctx *context,
273  grn_obj *object, const gchar *expression)
274 {
275  if (object) {
276  cut_test_pass();
277  } else {
278  cut_test_fail(cut_take_printf("expected: <%s> is not NULL: <%s>",
279  expression,
280  context->errbuf));
281  }
282 }
283 
284 void
285 grn_test_assert_select_helper (grn_ctx *context,
286  const GList *expected,
287  grn_obj *select_result,
288  const gchar *text_column_name,
289  const gchar *expected_expression,
290  const gchar *select_result_expression,
291  const gchar *text_column_name_expression)
292 {
293  const GList *records;
294  GList *sorted_records, *sorted_expected;
295 
296  records = grn_test_table_collect_string(context,
297  select_result,
298  text_column_name);
299 
300  sorted_expected = g_list_copy((GList *)expected);
301  sorted_expected = g_list_sort(sorted_expected, (GCompareFunc)g_utf8_collate);
302  gcut_take_list(sorted_expected, NULL);
303 
304  sorted_records = g_list_copy((GList *)records);
305  sorted_records = g_list_sort(sorted_records, (GCompareFunc)g_utf8_collate);
306  gcut_take_list(sorted_records, NULL);
307 
308  gcut_assert_equal_list_string(sorted_expected, sorted_records);
309 }
310 
311 void
312 grn_test_assert_expr_helper (grn_ctx *context,
313  const gchar *inspected,
314  grn_obj *expr,
315  const gchar *inspected_expression,
316  const gchar *expr_expression)
317 {
318  grn_obj buffer;
319  const gchar *actual_inspected;
320 
321  GRN_TEXT_INIT(&buffer, 0);
322  grn_expr_inspect(context, &buffer, expr);
323  GRN_TEXT_PUTC(context, &buffer, '\0');
324  actual_inspected = cut_take_strdup(GRN_TEXT_VALUE(&buffer));
325  GRN_OBJ_FIN(context, &buffer);
326  cut_assert_equal_string(inspected, actual_inspected);
327 }
328 
329 void
330 grn_test_assert_equal_encoding_helper (grn_encoding expected,
331  grn_encoding actual,
332  const gchar *expression_expected,
333  const gchar *expression_actual)
334 {
335  if (expected == actual) {
336  cut_test_pass();
337  } else {
338  cut_test_fail(cut_take_printf("<%s> == <%s>\n"
339  "expected: <%s>\n"
340  " but was: <%s>",
341  expression_expected,
342  expression_actual,
343  grn_encoding_to_string(expected),
344  grn_encoding_to_string(actual)));
345  }
346 }
347 
348 void
349 grn_test_assert_equal_table_helper (grn_ctx *context,
350  const GList *expected,
351  grn_obj *table,
352  const gchar *text_column_name,
353  const gchar *expected_expression,
354  const gchar *select_result_expression,
355  const gchar *text_column_name_expression)
356 {
357  const GList *records;
358 
359  records = grn_test_table_collect_string(context, table, text_column_name);
360  gcut_assert_equal_list_string(expected, records);
361 }
362 
363 void
364 grn_test_assert_send_command_error_helper (grn_ctx *context,
365  grn_rc expected_rc,
366  const gchar *expected_message,
367  const gchar *command,
368  const gchar *expected_rc_expression,
369  const gchar *expected_message_expression,
370  const gchar *command_expression)
371 {
372  const gchar **lines;
373 
374  lines = cut_take_string_array(g_strsplit(command, "\n", 0));
375  for (; *lines; lines++) {
376  grn_ctx_send(context, *lines, strlen(*lines), 0);
377  if (context->rc) {
378  break;
379  }
380  }
381 
382  if (context->rc == expected_rc &&
383  cut_equal_string(expected_message, context->errbuf)) {
384  gchar *command_result;
385  unsigned int command_result_length;
386  int flags = 0;
387 
388  cut_test_pass();
389  grn_ctx_recv(context, &command_result, &command_result_length, &flags);
390  } else {
391  cut_set_expected(cut_take_printf("<%s>(%s)",
392  expected_message,
393  grn_rc_to_string(expected_rc)));
394  cut_set_actual(cut_take_printf("<%s>(%s)",
395  context->errbuf,
396  grn_rc_to_string(context->rc)));
397  cut_test_fail(cut_take_printf("<send(\"%s\")>\n"
398  "%s:%d: %s():",
399  command_expression,
400  context->errfile, context->errline,
401  context->errfunc));
402  }
403 }
Generated on Sun Nov 10 2013 09:49:05 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2