void
test_near_geo_point(gpointer data)
{
grn_id id;
int offset, limit;
const GList *expected_keys;
GList *actual_keys = NULL;
grn_table_sort_key keys[2];
grn_obj base, base_string, location;
create_geo_table(cut_take_printf(" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"],\n"
" [\"%s\"]",
TAKEN_POINT(0, 0, 0,
180, 0, 0),
TAKEN_POINT(0, 0, 0,
-179, -59, -59),
TAKEN_POINT(-1, -1, -1,
180, 0, 0),
TAKEN_POINT(2, 1, 1,
180, 0, 0),
TAKEN_POINT(-2, -1, -1,
-179, -59, -59),
TAKEN_POINT(1, 2, 1,
-179, -59, -59),
TAKEN_POINT(90, 0, 0,
0, 0, 0),
TAKEN_POINT(-90, 0, 0,
1, 0, 0),
TAKEN_POINT(1, 0, 0,
1, 0, 0),
TAKEN_POINT(1, 1, 0,
1, 1, 0),
TAKEN_POINT(1, 1, 1,
1, 1, 1),
TAKEN_POINT(-1, 0, 0,
1, 1, 1),
TAKEN_POINT(-1, -1, -1,
0, 0, 0),
TAKEN_POINT(-1, -2, -1,
-1, -1, -1),
TAKEN_POINT(1, 1, 10,
-1, -1, -1)));
result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
NULL, table);
grn_test_assert_context(context);
GRN_TEXT_INIT(&base_string, 0);
GRN_TEXT_SETS(context, &base_string, gcut_data_get_string(data, "base"));
GRN_WGS84_GEO_POINT_INIT(&base, 0);
grn_obj_cast(context, &base_string, &base, FALSE);
GRN_OBJ_FIN(context, &base_string);
offset = gcut_data_get_int(data, "offset");
if (offset > 0) {
cut_omit("geo sort doesn't support offset yet.");
}
limit = gcut_data_get_int(data, "limit");
keys[0].key = column;
keys[0].flags = GRN_TABLE_SORT_GEO;
keys[0].offset = 0;
keys[1].key = &base;
keys[1].flags = 0;
keys[1].offset = 0;
grn_table_sort(context, table, offset, limit, result, keys, 2);
GRN_OBJ_FIN(context, &base);
grn_test_assert_context(context);
cursor = grn_table_cursor_open(context, result,
NULL, 0, NULL, 0, 0, -1,
GRN_CURSOR_ASCENDING);
grn_test_assert_context(context);
GRN_WGS84_GEO_POINT_INIT(&location, 0);
while ((id = grn_table_cursor_next(context, cursor))) {
gint32 *key;
int key_size;
gint latitude, longitude;
key_size = grn_table_cursor_get_value(context, cursor, (void **)&key);
GRN_BULK_REWIND(&location);
grn_obj_get_value(context, column, *key, &location);
GRN_GEO_POINT_VALUE(&location, latitude, longitude);
actual_keys = g_list_append(actual_keys,
inspect_point(latitude, longitude));
}
GRN_OBJ_FIN(context, &location);
gcut_take_list(actual_keys, g_free);
expected_keys = gcut_data_get_pointer(data, "expected");
gcut_assert_equal_list_string(expected_keys, actual_keys);
}
void
data_text_otoj(void)
{
#define ADD_DATUM(label, expected, type, ...) \
gcut_add_datum(label, \
"expected", G_TYPE_STRING, expected, \
"type", G_TYPE_INT, type, \
__VA_ARGS__);
ADD_DATUM("Void", "", GRN_DB_VOID, NULL);
ADD_DATUM("Bool", "true", GRN_DB_BOOL,
"value", G_TYPE_BOOLEAN, TRUE,
NULL);
ADD_DATUM("Bool", "false", GRN_DB_BOOL,
"value", G_TYPE_BOOLEAN, FALSE,
NULL);
ADD_DATUM("Int8 (min)", cut_take_printf("%d", INT8_MIN), GRN_DB_INT8,
"value", G_TYPE_INT, INT8_MIN,
NULL);
ADD_DATUM("Int8 (max)", cut_take_printf("%d", INT8_MAX), GRN_DB_INT8,
"value", G_TYPE_INT, INT8_MAX,
NULL);
ADD_DATUM("UInt8 (min)", "0", GRN_DB_UINT8,
"value", G_TYPE_UINT, 0,
NULL);
ADD_DATUM("UInt8 (max)", cut_take_printf("%u", UINT8_MAX), GRN_DB_UINT8,
"value", G_TYPE_UINT, UINT8_MAX,
NULL);
ADD_DATUM("Int16 (min)", cut_take_printf("%d", INT16_MIN), GRN_DB_INT16,
"value", G_TYPE_INT, INT16_MIN,
NULL);
ADD_DATUM("Int16 (max)", cut_take_printf("%d", INT16_MAX), GRN_DB_INT16,
"value", G_TYPE_INT, INT16_MAX,
NULL);
ADD_DATUM("UInt16 (min)", "0", GRN_DB_UINT16,
"value", G_TYPE_UINT, 0,
NULL);
ADD_DATUM("UInt16 (max)", cut_take_printf("%u", UINT16_MAX), GRN_DB_UINT16,
"value", G_TYPE_UINT, UINT16_MAX,
NULL);
ADD_DATUM("Int32 (min)", cut_take_printf("%d", INT32_MIN), GRN_DB_INT32,
"value", G_TYPE_INT, INT32_MIN,
NULL);
ADD_DATUM("Int32 (max)", cut_take_printf("%d", INT32_MAX), GRN_DB_INT32,
"value", G_TYPE_INT, INT32_MAX,
NULL);
ADD_DATUM("UInt32 (min)", "0", GRN_DB_UINT32,
"value", G_TYPE_UINT, 0,
NULL);
ADD_DATUM("UInt32 (max)", cut_take_printf("%u", UINT32_MAX), GRN_DB_UINT32,
"value", G_TYPE_UINT, UINT32_MAX,
NULL);
ADD_DATUM("Int64 (min)",
cut_take_printf("%" G_GINT64_FORMAT, INT64_MIN), GRN_DB_INT64,
"value", G_TYPE_INT64, INT64_MIN,
NULL);
ADD_DATUM("Int64 (max)",
cut_take_printf("%" G_GINT64_FORMAT, INT64_MAX), GRN_DB_INT64,
"value", G_TYPE_INT64, INT64_MAX,
NULL);
ADD_DATUM("UInt64 (min)", "0", GRN_DB_UINT64,
"value", G_TYPE_UINT64, G_GUINT64_CONSTANT(0),
NULL);
ADD_DATUM("UInt64 (max)",
cut_take_printf("%" G_GUINT64_FORMAT, UINT64_MAX), GRN_DB_UINT64,
"value", G_TYPE_UINT64, UINT64_MAX,
NULL);
ADD_DATUM("Float", cut_take_printf("%g", 2.9), GRN_DB_FLOAT,
"value", G_TYPE_DOUBLE, 2.9,
NULL);
ADD_DATUM("Time", "1271053050.21148", GRN_DB_TIME,
"value", G_TYPE_INT64, GRN_TIME_PACK(1271053050, 211479),
NULL);
ADD_DATUM("ShortText",
"\"\\\"'\\\\aAzZ09 \\n\\t\\r日本語\"", GRN_DB_SHORT_TEXT,
"value", G_TYPE_STRING, "\"'\\aAzZ09 \n\t\r日本語",
NULL);
ADD_DATUM("Text",
"\"\\\"'\\\\aAzZ09 \\n\\t\\r日本語\"", GRN_DB_TEXT,
"value", G_TYPE_STRING, "\"'\\aAzZ09 \n\t\r日本語",
NULL);
ADD_DATUM("LongText",
"\"\\\"'\\\\aAzZ09 \\n\\t\\r日本語\"", GRN_DB_LONG_TEXT,
"value", G_TYPE_STRING, "\"'\\aAzZ09 \n\t\r日本語",
NULL);
ADD_DATUM("TokyoGeoPoint", "\"35681396x139766049\"", GRN_DB_TOKYO_GEO_POINT,
"latitude", G_TYPE_INT, 35681396,
"longitude", G_TYPE_INT, 139766049,
NULL);
ADD_DATUM("WGS84GeoPoint", "\"36032548x140164867\"", GRN_DB_WGS84_GEO_POINT,
"latitude", G_TYPE_INT, 36032548,
"longitude", G_TYPE_INT, 140164867,
NULL);
/* FIXME* unknown bulk */
/* FIXME: GRN_UVECTOR */
/* FIXME: GRN_VECTOR */
/* FIXME: table with format */
/* FIXME: table without format */
/* FIXME: grn_text_atoj */
#undef ADD_DATUM
}
const gchar *
grn_rc_to_string(grn_rc rc)
{
switch (rc) {
case GRN_SUCCESS:
return "GRN_SUCCESS";
case GRN_END_OF_DATA:
return "GRN_END_OF_DATA";
case GRN_UNKNOWN_ERROR:
return "GRN_UNKNOWN_ERROR";
case GRN_OPERATION_NOT_PERMITTED:
return "GRN_OPERATION_NOT_PERMITTED";
case GRN_NO_SUCH_FILE_OR_DIRECTORY:
return "GRN_NO_SUCH_FILE_OR_DIRECTORY";
case GRN_NO_SUCH_PROCESS:
return "GRN_NO_SUCH_PROCESS";
case GRN_INTERRUPTED_FUNCTION_CALL:
return "GRN_INTERRUPTED_FUNCTION_CALL";
case GRN_INPUT_OUTPUT_ERROR:
return "GRN_INPUT_OUTPUT_ERROR";
case GRN_NO_SUCH_DEVICE_OR_ADDRESS:
return "GRN_NO_SUCH_DEVICE_OR_ADDRESS";
case GRN_ARG_LIST_TOO_LONG:
return "GRN_ARG_LIST_TOO_LONG";
case GRN_EXEC_FORMAT_ERROR:
return "GRN_EXEC_FORMAT_ERROR";
case GRN_BAD_FILE_DESCRIPTOR:
return "GRN_BAD_FILE_DESCRIPTOR";
case GRN_NO_CHILD_PROCESSES:
return "GRN_NO_CHILD_PROCESSES";
case GRN_RESOURCE_TEMPORARILY_UNAVAILABLE:
return "GRN_RESOURCE_TEMPORARILY_UNAVAILABLE";
case GRN_NOT_ENOUGH_SPACE:
return "GRN_NOT_ENOUGH_SPACE";
case GRN_PERMISSION_DENIED:
return "GRN_PERMISSION_DENIED";
case GRN_BAD_ADDRESS:
return "GRN_BAD_ADDRESS";
case GRN_RESOURCE_BUSY:
return "GRN_RESOURCE_BUSY";
case GRN_FILE_EXISTS:
return "GRN_FILE_EXISTS";
case GRN_IMPROPER_LINK:
return "GRN_IMPROPER_LINK";
case GRN_NO_SUCH_DEVICE:
return "GRN_NO_SUCH_DEVICE";
case GRN_NOT_A_DIRECTORY:
return "GRN_NOT_A_DIRECTORY";
case GRN_IS_A_DIRECTORY:
return "GRN_IS_A_DIRECTORY";
case GRN_INVALID_ARGUMENT:
return "GRN_INVALID_ARGUMENT";
case GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM:
return "GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM";
case GRN_TOO_MANY_OPEN_FILES:
return "GRN_TOO_MANY_OPEN_FILES";
case GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION:
return "GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION";
case GRN_FILE_TOO_LARGE:
return "GRN_FILE_TOO_LARGE";
case GRN_NO_SPACE_LEFT_ON_DEVICE:
return "GRN_NO_SPACE_LEFT_ON_DEVICE";
case GRN_INVALID_SEEK:
return "GRN_INVALID_SEEK";
case GRN_READ_ONLY_FILE_SYSTEM:
return "GRN_READ_ONLY_FILE_SYSTEM";
case GRN_TOO_MANY_LINKS:
return "GRN_TOO_MANY_LINKS";
case GRN_BROKEN_PIPE:
return "GRN_BROKEN_PIPE";
case GRN_DOMAIN_ERROR:
return "GRN_DOMAIN_ERROR";
case GRN_RESULT_TOO_LARGE:
return "GRN_RESULT_TOO_LARGE";
case GRN_RESOURCE_DEADLOCK_AVOIDED:
return "GRN_RESOURCE_DEADLOCK_AVOIDED";
case GRN_NO_MEMORY_AVAILABLE:
return "GRN_NO_MEMORY_AVAILABLE";
case GRN_FILENAME_TOO_LONG:
return "GRN_FILENAME_TOO_LONG";
case GRN_NO_LOCKS_AVAILABLE:
return "GRN_NO_LOCKS_AVAILABLE";
case GRN_FUNCTION_NOT_IMPLEMENTED:
return "GRN_FUNCTION_NOT_IMPLEMENTED";
case GRN_DIRECTORY_NOT_EMPTY:
return "GRN_DIRECTORY_NOT_EMPTY";
case GRN_ILLEGAL_BYTE_SEQUENCE:
return "GRN_ILLEGAL_BYTE_SEQUENCE";
case GRN_SOCKET_NOT_INITIALIZED:
return "GRN_SOCKET_NOT_INITIALIZED";
case GRN_OPERATION_WOULD_BLOCK:
return "GRN_OPERATION_WOULD_BLOCK";
case GRN_ADDRESS_IS_NOT_AVAILABLE:
return "GRN_ADDRESS_IS_NOT_AVAILABLE";
case GRN_NETWORK_IS_DOWN:
return "GRN_NETWORK_IS_DOWN";
case GRN_NO_BUFFER:
return "GRN_NO_BUFFER";
case GRN_SOCKET_IS_ALREADY_CONNECTED:
return "GRN_SOCKET_IS_ALREADY_CONNECTED";
case GRN_SOCKET_IS_NOT_CONNECTED:
return "GRN_SOCKET_IS_NOT_CONNECTED";
case GRN_SOCKET_IS_ALREADY_SHUTDOWNED:
return "GRN_SOCKET_IS_ALREADY_SHUTDOWNED";
case GRN_OPERATION_TIMEOUT:
return "GRN_OPERATION_TIMEOUT";
case GRN_CONNECTION_REFUSED:
return "GRN_CONNECTION_REFUSED";
case GRN_RANGE_ERROR:
return "GRN_RANGE_ERROR";
case GRN_TOKENIZER_ERROR:
return "GRN_TOKENIZER_ERROR";
case GRN_FILE_CORRUPT:
return "GRN_FILE_CORRUPT";
case GRN_INVALID_FORMAT:
return "GRN_INVALID_FORMAT";
case GRN_OBJECT_CORRUPT:
return "GRN_OBJECT_CORRUPT";
case GRN_TOO_MANY_SYMBOLIC_LINKS:
return "GRN_TOO_MANY_SYMBOLIC_LINKS";
case GRN_NOT_SOCKET:
return "GRN_NOT_SOCKET";
case GRN_OPERATION_NOT_SUPPORTED:
return "GRN_OPERATION_NOT_SUPPORTED";
case GRN_ADDRESS_IS_IN_USE:
return "GRN_ADDRESS_IS_IN_USE";
case GRN_ZLIB_ERROR:
return "GRN_ZLIB_ERROR";
case GRN_LZO_ERROR:
return "GRN_LZO_ERROR";
case GRN_STACK_OVER_FLOW:
return "GRN_STACK_OVER_FLOW";
case GRN_SYNTAX_ERROR:
return "GRN_SYNTAX_ERROR";
case GRN_RETRY_MAX:
return "GRN_RETRY_MAX";
case GRN_INCOMPATIBLE_FILE_FORMAT:
return "GRN_INCOMPATIBLE_FILE_FORMAT";
case GRN_UPDATE_NOT_ALLOWED:
return "GRN_UPDATE_NOT_ALLOWED";
default:
return cut_take_printf("GRN_UNKNOWN_STATUS (%d)", rc);
}
}
void
test_help_all (void)
{
const gchar *format;
const gchar *help_all_message;
format =
"Usage:" LINE_FEED_CODE
" %s [OPTION...] TEST_DIRECTORY" LINE_FEED_CODE
" %s --mode=analyze [OPTION...] LOG_DIRECTORY" LINE_FEED_CODE
" %s --mode=play [OPTION...] LOG_FILE" LINE_FEED_CODE
"" LINE_FEED_CODE
"Help Options:" LINE_FEED_CODE
#if GLIB_CHECK_VERSION(2, 21, 0)
" -h, --help Show help options" LINE_FEED_CODE
#else
" -?, --help Show help options" LINE_FEED_CODE
#endif
" --help-all Show all help options" LINE_FEED_CODE
" --help-stream Show stream options" LINE_FEED_CODE
" --help-report Show report options" LINE_FEED_CODE
" --help-ui Show UI options" LINE_FEED_CODE
" --help-console-ui Show console UI options" LINE_FEED_CODE
#ifdef HAVE_GTK
" --help-gtk Show GTK+ Options" LINE_FEED_CODE
#endif
"" LINE_FEED_CODE
"Stream Options" LINE_FEED_CODE
" --stream=[xml] Specify stream" LINE_FEED_CODE
" --stream-fd=FILE_DESCRIPTOR Stream to FILE_DESCRIPTOR (default: stdout)" LINE_FEED_CODE
" --stream-directory=DIRECTORY Stream to a file under DIRECTORY (default: none)" LINE_FEED_CODE
" --stream-log-directory=DIRECTORY Obsoleted. Use --stream-directory instead" LINE_FEED_CODE
"" LINE_FEED_CODE
"Report Options" LINE_FEED_CODE
#if defined(HAVE_PANGO_CAIRO) && defined(HAVE_CAIRO_PDF)
" --pdf-report=FILE Set filename of pdf report" LINE_FEED_CODE
#endif
" --xml-report=FILE Set filename of xml report" LINE_FEED_CODE
"" LINE_FEED_CODE
"UI Options" LINE_FEED_CODE
#ifdef HAVE_GTK
" -u, --ui=[console|gtk] Specify UI" LINE_FEED_CODE
#else
" -u, --ui=[console] Specify UI" LINE_FEED_CODE
#endif
"" LINE_FEED_CODE
"Console UI Options" LINE_FEED_CODE
" -v, --verbose=[s|silent|n|normal|v|verbose] Set verbose level" LINE_FEED_CODE
" -c, --color=[yes|true|no|false|auto] Output log with colors" LINE_FEED_CODE
" --notify=[yes|true|no|false|auto] Notify test result" LINE_FEED_CODE
" --show-detail-immediately=[yes|true|no|false] Show test detail immediately" LINE_FEED_CODE
"" LINE_FEED_CODE
#ifdef HAVE_GTK
"GTK+ Options" LINE_FEED_CODE
" --class=CLASS Program class as used by the window manager" LINE_FEED_CODE
" --gtk-name=NAME Program name as used by the window manager" LINE_FEED_CODE
" --screen=SCREEN X screen to use" LINE_FEED_CODE
# ifdef HAVE_GTK_ENABLE_DEBUG
" --gdk-debug=FLAGS GDK debugging flags to set" LINE_FEED_CODE
" --gdk-no-debug=FLAGS GDK debugging flags to unset" LINE_FEED_CODE
# endif
# ifdef GDK_WINDOWING_X11
" --sync Make X calls synchronous" LINE_FEED_CODE
# elif defined(GDK_WINDOWING_WIN32)
" --sync Don't batch GDI requests" LINE_FEED_CODE
" --no-wintab Don't use the Wintab API for tablet support" LINE_FEED_CODE
" --ignore-wintab Same as --no-wintab" LINE_FEED_CODE
" --use-wintab Do use the Wintab API [default]" LINE_FEED_CODE
" --max-colors=COLORS Size of the palette in 8 bit mode" LINE_FEED_CODE
# endif
" --gtk-module=MODULES Load additional GTK+ modules" LINE_FEED_CODE
" --g-fatal-warnings Make all warnings fatal" LINE_FEED_CODE
# ifdef HAVE_GTK_ENABLE_DEBUG
" --gtk-debug=FLAGS GTK+ debugging flags to set" LINE_FEED_CODE
" --gtk-no-debug=FLAGS GTK+ debugging flags to unset" LINE_FEED_CODE
# endif
"" LINE_FEED_CODE
#endif
"Application Options:" LINE_FEED_CODE
" --version Show version" LINE_FEED_CODE
" --mode=[test|analyze|play] Set run mode (default: test)" LINE_FEED_CODE
" -s, --source-directory=DIRECTORY Set directory of source code" LINE_FEED_CODE
" -n, --name=TEST_NAME Specify tests" LINE_FEED_CODE
" -t, --test-case=TEST_CASE_NAME Specify test cases" LINE_FEED_CODE
" -m, --multi-thread Run test cases and iterated tests with multi-thread" LINE_FEED_CODE
" --max-threads=MAX_THREADS Run test cases and iterated tests with MAX_THREADS threads concurrently at a maximum (default: 10; -1 is no limit)" LINE_FEED_CODE
" --disable-signal-handling Disable signal handling" LINE_FEED_CODE
" --test-case-order=[none|name|name-desc] Sort test case by. Default is 'none'." LINE_FEED_CODE
" --exclude-file=FILE Skip files" LINE_FEED_CODE
" --exclude-directory=DIRECTORY Skip directories" LINE_FEED_CODE
" --fatal-failures Treat failures as fatal problem" LINE_FEED_CODE
" --keep-opening-modules Keep opening loaded modules to resolve symbols for debugging" LINE_FEED_CODE
" --enable-convenience-attribute-definition Enable convenience but danger '#{ATTRIBUTE_NAME}_#{TEST_NAME - 'test_' PREFIX}' attribute set function" LINE_FEED_CODE
" --stop-before-test Set breakpoints at each line which invokes test. You can step into a test function with your debugger easily." LINE_FEED_CODE
#ifdef HAVE_GTK
" --display=DISPLAY X display to use" LINE_FEED_CODE
#endif
"" LINE_FEED_CODE;
help_all_message = cut_take_printf(format,
g_get_prgname(),
g_get_prgname(),
g_get_prgname());
cut_assert(run_cutter("--help-all"));
cut_assert_exit_success();
cut_assert_equal_string(help_all_message, stdout_string);
}
void
test_near_geo_point(gpointer data)
{
grn_id id;
int min_size, offset, limit, flags;
grn_obj max_string, max;
const GList *expected_keys;
GList *actual_keys = NULL;
create_geo_point_table(
cut_take_printf(" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"],"
" [\"%s\"]",
TAKEN_POINT(1, 2, 3,
4, 5, 6),
TAKEN_POINT(1, 2, 3,
7, 8, 9),
TAKEN_POINT(7, 8, 9,
4, 5, 6),
TAKEN_POINT(89, 59, 59,
179, 59, 59),
TAKEN_POINT(89, 59, 59,
179, -59, -59),
TAKEN_POINT(88, 58, 58,
178, 58, 58),
TAKEN_POINT(-89, -59, -59,
-179, -59, -59),
TAKEN_POINT(-89, -59, -59,
179, 59, 59),
TAKEN_POINT(-88, -58, -58,
-178, -58, -58)));
min_size = gcut_data_get_int(data, "min-size");
GRN_TEXT_INIT(&max_string, 0);
GRN_TEXT_PUTS(context, &max_string, gcut_data_get_string(data, "max"));
GRN_WGS84_GEO_POINT_INIT(&max, 0);
grn_obj_cast(context, &max_string, &max, FALSE);
grn_obj_unlink(context, &max_string);
offset = gcut_data_get_int(data, "offset");
limit = gcut_data_get_int(data, "limit");
flags = gcut_data_get_int(data, "flags");
cursor = grn_table_cursor_open(context, table,
NULL, min_size,
GRN_BULK_HEAD(&max), GRN_BULK_VSIZE(&max),
offset, limit,
flags | GRN_CURSOR_PREFIX);
grn_obj_unlink(context, &max);
grn_test_assert_context(context);
while ((id = grn_table_cursor_next(context, cursor))) {
grn_geo_point *key;
int key_size;
key_size = grn_table_cursor_get_key(context, cursor, (void **)&key);
actual_keys = g_list_append(actual_keys,
g_strdup_printf("%dx%d",
key->latitude,
key->longitude));
}
gcut_take_list(actual_keys, g_free);
expected_keys = gcut_data_get_pointer(data, "expected");
gcut_assert_equal_list_string(expected_keys, actual_keys);
}
