Groonga 3.0.9 Source Code Document
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
test-dat-cursor.cpp
Go to the documentation of this file.
1 /* -*- c-basic-offset: 2; coding: utf-8 -*- */
2 /*
3  Copyright (C) 2011-2012 Brazil
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 <dat.h>
20 
21 #include <gcutter.h>
22 #include <glib/gstdio.h>
23 #include <cppcutter.h>
24 
25 #include <grn-assertions.h>
26 
27 #include <algorithm>
28 #include <cstdio>
29 #include <cstdlib>
30 #include <ctime>
31 #include <set>
32 #include <string>
33 #include <vector>
34 
35 namespace
36 {
37  void create_key(std::string *key, std::size_t min_length,
38  std::size_t max_length)
39  {
40  key->resize(min_length + (std::rand() % (max_length - min_length + 1)));
41  for (std::size_t i = 0; i < key->size(); ++i) {
42  (*key)[i] = '0' + (std::rand() % 10);
43  }
44  }
45 
46  void create_keys(std::vector<std::string> *keys, std::size_t num_keys,
47  std::size_t min_length, std::size_t max_length)
48  {
49  std::string key;
50  std::set<std::string> keyset;
51  while (keyset.size() < num_keys) {
52  create_key(&key, min_length, max_length);
53  keyset.insert(key);
54  }
55  std::vector<std::string>(keyset.begin(), keyset.end()).swap(*keys);
56  std::random_shuffle(keys->begin(), keys->end());
57  }
58 }
59 
60 namespace test_dat_cursor
61 {
62  grn_ctx ctx;
63 
64  void cut_setup(void)
65  {
66  std::srand(static_cast<unsigned int>(std::time(NULL)));
67 
68  grn_ctx_init(&ctx, 0);
69  }
70 
71  void cut_teardown(void)
72  {
73  grn_ctx_fin(&ctx);
74  }
75 
76  grn_dat *create_trie(const std::vector<std::string> &keys) {
77  grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0,
79  cppcut_assert_not_null(dat);
80  for (std::size_t i = 0; i < keys.size(); ++i) {
81  const char * const ptr = keys[i].c_str();
82  const uint32_t length = static_cast<uint32_t>(keys[i].length());
83  cppcut_assert_equal(static_cast<grn_id>(i + 1),
84  grn_dat_add(&ctx, dat, ptr, length, NULL, NULL));
85  }
86  return dat;
87  }
88 
89  void test_cursor_open(void)
90  {
91  grn_dat *dat = grn_dat_create(&ctx, NULL, 0, 0, 0);
92  cppcut_assert_not_null(dat);
94  &ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_ID);
95  cppcut_assert_not_null(cursor);
96  grn_dat_cursor_close(&ctx, cursor);
98 
99  std::vector<std::string> keys;
100  create_keys(&keys, 100, 3, 5);
101  dat = create_trie(keys);
102  cursor = grn_dat_cursor_open(
103  &ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_KEY);
104  cppcut_assert_not_null(cursor);
105  grn_dat_cursor_close(&ctx, cursor);
107  }
108 
109  void test_cursor_next(void)
110  {
111  std::vector<std::string> keys;
112  create_keys(&keys, 1000, 3, 5);
113  grn_dat * const dat = create_trie(keys);
114 
115  grn_dat_cursor * const cursor = grn_dat_cursor_open(
116  &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
117  cppcut_assert_not_null(cursor);
118  for (std::size_t i = 1; i <= keys.size(); ++i) {
119  cppcut_assert_equal(static_cast<grn_id>(i),
120  grn_dat_cursor_next(&ctx, cursor));
121  }
122  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
123  grn_dat_cursor_next(&ctx, cursor));
124  grn_dat_cursor_close(&ctx, cursor);
125 
127  }
128 
130  {
131  std::vector<std::string> keys;
132  create_keys(&keys, 1000, 3, 5);
133  grn_dat * const dat = create_trie(keys);
134 
135  grn_dat_cursor * const cursor = grn_dat_cursor_open(
136  &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
137  cppcut_assert_not_null(cursor);
138  for (std::size_t i = 0; i < keys.size(); ++i) {
139  const grn_id key_id = static_cast<grn_id>(i + 1);
140  const int length = static_cast<int>(keys[i].length());
141  cppcut_assert_equal(key_id, grn_dat_cursor_next(&ctx, cursor));
142  const void *key_ptr;
143  cppcut_assert_equal(length,
144  grn_dat_cursor_get_key(&ctx, cursor, &key_ptr));
145  uint32_t key_length;
146  cppcut_assert_equal(_grn_dat_key(&ctx, dat, key_id, &key_length),
147  static_cast<const char *>(key_ptr));
148  }
149  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
150  grn_dat_cursor_next(&ctx, cursor));
151  grn_dat_cursor_close(&ctx, cursor);
152 
154  }
155 
157  {
158  std::vector<std::string> keys;
159  create_keys(&keys, 1000, 3, 5);
160  grn_dat * const dat = create_trie(keys);
161 
163  &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
164  cppcut_assert_not_null(cursor);
165  for (std::size_t i = 1; i <= keys.size(); ++i) {
166  cppcut_assert_equal(static_cast<grn_id>(i),
167  grn_dat_cursor_next(&ctx, cursor));
168  if (i & 1) {
170  grn_dat_cursor_delete(&ctx, cursor, NULL));
171  }
172  }
173  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
174  grn_dat_cursor_next(&ctx, cursor));
175  grn_dat_cursor_close(&ctx, cursor);
176 
177  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1,
179  cppcut_assert_not_null(cursor);
180  for (std::size_t i = 1; i <= (keys.size() / 2); ++i) {
181  cppcut_assert_equal(static_cast<grn_id>(i * 2),
182  grn_dat_cursor_next(&ctx, cursor));
183  }
184  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
185  grn_dat_cursor_next(&ctx, cursor));
186  grn_dat_cursor_close(&ctx, cursor);
187 
189  }
190 
191  void test_cursor_by_id(void)
192  {
193  std::vector<std::string> keys;
194  keys.push_back("mandarin");
195  keys.push_back("grapefruit");
196  keys.push_back("orange");
197  keys.push_back("citron");
198  grn_dat * const dat = create_trie(keys);
199 
200  grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
201  0, -1, GRN_CURSOR_BY_ID);
202  cppcut_assert_not_null(cursor);
203  cppcut_assert_equal(static_cast<grn_id>(1),
204  grn_dat_cursor_next(&ctx, cursor));
205  cppcut_assert_equal(static_cast<grn_id>(2),
206  grn_dat_cursor_next(&ctx, cursor));
207  cppcut_assert_equal(static_cast<grn_id>(3),
208  grn_dat_cursor_next(&ctx, cursor));
209  cppcut_assert_equal(static_cast<grn_id>(4),
210  grn_dat_cursor_next(&ctx, cursor));
211  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
212  grn_dat_cursor_next(&ctx, cursor));
213  grn_dat_cursor_close(&ctx, cursor);
214 
215  cursor = grn_dat_cursor_open(&ctx, dat, keys[2].c_str(), keys[2].length(),
216  NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
217  cppcut_assert_not_null(cursor);
218  cppcut_assert_equal(static_cast<grn_id>(3),
219  grn_dat_cursor_next(&ctx, cursor));
220  cppcut_assert_equal(static_cast<grn_id>(4),
221  grn_dat_cursor_next(&ctx, cursor));
222  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
223  grn_dat_cursor_next(&ctx, cursor));
224  grn_dat_cursor_close(&ctx, cursor);
225 
226  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(),
227  keys[1].length(), 0, -1, GRN_CURSOR_BY_ID);
228  cppcut_assert_not_null(cursor);
229  cppcut_assert_equal(static_cast<grn_id>(1),
230  grn_dat_cursor_next(&ctx, cursor));
231  cppcut_assert_equal(static_cast<grn_id>(2),
232  grn_dat_cursor_next(&ctx, cursor));
233  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
234  grn_dat_cursor_next(&ctx, cursor));
235  grn_dat_cursor_close(&ctx, cursor);
236 
237  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
238  1, 2, GRN_CURSOR_BY_ID);
239  cppcut_assert_not_null(cursor);
240  cppcut_assert_equal(static_cast<grn_id>(2),
241  grn_dat_cursor_next(&ctx, cursor));
242  cppcut_assert_equal(static_cast<grn_id>(3),
243  grn_dat_cursor_next(&ctx, cursor));
244  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
245  grn_dat_cursor_next(&ctx, cursor));
246  grn_dat_cursor_close(&ctx, cursor);
247 
248  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
250  cppcut_assert_not_null(cursor);
251  cppcut_assert_equal(static_cast<grn_id>(2),
252  grn_dat_cursor_next(&ctx, cursor));
253  cppcut_assert_equal(static_cast<grn_id>(3),
254  grn_dat_cursor_next(&ctx, cursor));
255  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
256  grn_dat_cursor_next(&ctx, cursor));
257  grn_dat_cursor_close(&ctx, cursor);
258 
259  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
261  cppcut_assert_not_null(cursor);
262  cppcut_assert_equal(static_cast<grn_id>(3),
263  grn_dat_cursor_next(&ctx, cursor));
264  cppcut_assert_equal(static_cast<grn_id>(2),
265  grn_dat_cursor_next(&ctx, cursor));
266  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
267  grn_dat_cursor_next(&ctx, cursor));
268  grn_dat_cursor_close(&ctx, cursor);
269 
270  cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
271  keys[2].c_str(), keys[2].length(),
273  cppcut_assert_not_null(cursor);
274  cppcut_assert_equal(static_cast<grn_id>(2),
275  grn_dat_cursor_next(&ctx, cursor));
276  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
277  grn_dat_cursor_next(&ctx, cursor));
278  grn_dat_cursor_close(&ctx, cursor);
279 
280  cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
281  keys[2].c_str(), keys[2].length(),
283  cppcut_assert_not_null(cursor);
284  cppcut_assert_equal(static_cast<grn_id>(3),
285  grn_dat_cursor_next(&ctx, cursor));
286  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
287  grn_dat_cursor_next(&ctx, cursor));
288  grn_dat_cursor_close(&ctx, cursor);
289 
291  }
292 
294  {
295  std::vector<std::string> keys;
296  keys.push_back("mandarin");
297  keys.push_back("grapefruit");
298  keys.push_back("orange");
299  keys.push_back("citron");
300  grn_dat * const dat = create_trie(keys);
301 
302  grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
303  0, -1, GRN_CURSOR_BY_KEY);
304  cppcut_assert_not_null(cursor);
305  cppcut_assert_equal(static_cast<grn_id>(4),
306  grn_dat_cursor_next(&ctx, cursor));
307  cppcut_assert_equal(static_cast<grn_id>(2),
308  grn_dat_cursor_next(&ctx, cursor));
309  cppcut_assert_equal(static_cast<grn_id>(1),
310  grn_dat_cursor_next(&ctx, cursor));
311  cppcut_assert_equal(static_cast<grn_id>(3),
312  grn_dat_cursor_next(&ctx, cursor));
313  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
314  grn_dat_cursor_next(&ctx, cursor));
315  grn_dat_cursor_close(&ctx, cursor);
316 
317  cursor = grn_dat_cursor_open(&ctx, dat, keys[0].c_str(), keys[0].length(),
318  NULL, 0, 0, -1, GRN_CURSOR_BY_KEY);
319  cppcut_assert_not_null(cursor);
320  cppcut_assert_equal(static_cast<grn_id>(1),
321  grn_dat_cursor_next(&ctx, cursor));
322  cppcut_assert_equal(static_cast<grn_id>(3),
323  grn_dat_cursor_next(&ctx, cursor));
324  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
325  grn_dat_cursor_next(&ctx, cursor));
326  grn_dat_cursor_close(&ctx, cursor);
327 
328  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(),
329  keys[1].length(), 0, -1, GRN_CURSOR_BY_KEY);
330  cppcut_assert_not_null(cursor);
331  cppcut_assert_equal(static_cast<grn_id>(4),
332  grn_dat_cursor_next(&ctx, cursor));
333  cppcut_assert_equal(static_cast<grn_id>(2),
334  grn_dat_cursor_next(&ctx, cursor));
335  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
336  grn_dat_cursor_next(&ctx, cursor));
337  grn_dat_cursor_close(&ctx, cursor);
338 
339  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
340  1, 2, GRN_CURSOR_BY_KEY);
341  cppcut_assert_not_null(cursor);
342  cppcut_assert_equal(static_cast<grn_id>(2),
343  grn_dat_cursor_next(&ctx, cursor));
344  cppcut_assert_equal(static_cast<grn_id>(1),
345  grn_dat_cursor_next(&ctx, cursor));
346  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
347  grn_dat_cursor_next(&ctx, cursor));
348  grn_dat_cursor_close(&ctx, cursor);
349 
350  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
352  cppcut_assert_not_null(cursor);
353  cppcut_assert_equal(static_cast<grn_id>(2),
354  grn_dat_cursor_next(&ctx, cursor));
355  cppcut_assert_equal(static_cast<grn_id>(1),
356  grn_dat_cursor_next(&ctx, cursor));
357  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
358  grn_dat_cursor_next(&ctx, cursor));
359  grn_dat_cursor_close(&ctx, cursor);
360 
361  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
363  cppcut_assert_not_null(cursor);
364  cppcut_assert_equal(static_cast<grn_id>(1),
365  grn_dat_cursor_next(&ctx, cursor));
366  cppcut_assert_equal(static_cast<grn_id>(2),
367  grn_dat_cursor_next(&ctx, cursor));
368  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
369  grn_dat_cursor_next(&ctx, cursor));
370  grn_dat_cursor_close(&ctx, cursor);
371 
372  cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
373  keys[0].c_str(), keys[0].length(),
375  cppcut_assert_not_null(cursor);
376  cppcut_assert_equal(static_cast<grn_id>(2),
377  grn_dat_cursor_next(&ctx, cursor));
378  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
379  grn_dat_cursor_next(&ctx, cursor));
380  grn_dat_cursor_close(&ctx, cursor);
381 
382  cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
383  keys[0].c_str(), keys[0].length(),
385  cppcut_assert_not_null(cursor);
386  cppcut_assert_equal(static_cast<grn_id>(1),
387  grn_dat_cursor_next(&ctx, cursor));
388  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
389  grn_dat_cursor_next(&ctx, cursor));
390  grn_dat_cursor_close(&ctx, cursor);
391 
393  }
394 
396  {
397  std::vector<std::string> keys;
398  keys.push_back("minimum");
399  keys.push_back("mind");
400  keys.push_back("minute");
401  keys.push_back("mild");
402  grn_dat * const dat = create_trie(keys);
403 
404  grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
405  0, -1, GRN_CURSOR_PREFIX);
406  cut_assert_null(cursor);
407 
408  cursor = grn_dat_cursor_open(&ctx, dat, "", 0, NULL, 0, 0, -1,
410  cut_assert_null(cursor);
411 
412  cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 0, -1,
414  cppcut_assert_not_null(cursor);
415  cppcut_assert_equal(static_cast<grn_id>(4),
416  grn_dat_cursor_next(&ctx, cursor));
417  cppcut_assert_equal(static_cast<grn_id>(2),
418  grn_dat_cursor_next(&ctx, cursor));
419  cppcut_assert_equal(static_cast<grn_id>(1),
420  grn_dat_cursor_next(&ctx, cursor));
421  cppcut_assert_equal(static_cast<grn_id>(3),
422  grn_dat_cursor_next(&ctx, cursor));
423  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
424  grn_dat_cursor_next(&ctx, cursor));
425  grn_dat_cursor_close(&ctx, cursor);
426 
427  cursor = grn_dat_cursor_open(&ctx, dat, "min", 3, NULL, 0, 0, -1,
429  cppcut_assert_not_null(cursor);
430  cppcut_assert_equal(static_cast<grn_id>(2),
431  grn_dat_cursor_next(&ctx, cursor));
432  cppcut_assert_equal(static_cast<grn_id>(1),
433  grn_dat_cursor_next(&ctx, cursor));
434  cppcut_assert_equal(static_cast<grn_id>(3),
435  grn_dat_cursor_next(&ctx, cursor));
436  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
437  grn_dat_cursor_next(&ctx, cursor));
438  grn_dat_cursor_close(&ctx, cursor);
439 
440  cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
442  cppcut_assert_not_null(cursor);
443  cppcut_assert_equal(static_cast<grn_id>(2),
444  grn_dat_cursor_next(&ctx, cursor));
445  cppcut_assert_equal(static_cast<grn_id>(1),
446  grn_dat_cursor_next(&ctx, cursor));
447  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
448  grn_dat_cursor_next(&ctx, cursor));
449  grn_dat_cursor_close(&ctx, cursor);
450 
451  cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
453  cppcut_assert_not_null(cursor);
454  cppcut_assert_equal(static_cast<grn_id>(2),
455  grn_dat_cursor_next(&ctx, cursor));
456  cppcut_assert_equal(static_cast<grn_id>(1),
457  grn_dat_cursor_next(&ctx, cursor));
458  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
459  grn_dat_cursor_next(&ctx, cursor));
460  grn_dat_cursor_close(&ctx, cursor);
461 
462  cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
464  cppcut_assert_not_null(cursor);
465  cppcut_assert_equal(static_cast<grn_id>(1),
466  grn_dat_cursor_next(&ctx, cursor));
467  cppcut_assert_equal(static_cast<grn_id>(2),
468  grn_dat_cursor_next(&ctx, cursor));
469  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
470  grn_dat_cursor_next(&ctx, cursor));
471  grn_dat_cursor_close(&ctx, cursor);
472 
473  cursor = grn_dat_cursor_open(&ctx, dat, "mind", 4, NULL, 0,
475  cppcut_assert_not_null(cursor);
476  cppcut_assert_equal(static_cast<grn_id>(2),
477  grn_dat_cursor_next(&ctx, cursor));
478  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
479  grn_dat_cursor_next(&ctx, cursor));
480  grn_dat_cursor_close(&ctx, cursor);
481 
482  cursor = grn_dat_cursor_open(&ctx, dat, "mind", 4, NULL, 0,
484  cppcut_assert_not_null(cursor);
485  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
486  grn_dat_cursor_next(&ctx, cursor));
487  grn_dat_cursor_close(&ctx, cursor);
488 
490  }
491 
493  {
494  std::vector<std::string> keys;
495  keys.push_back("not");
496  keys.push_back("no");
497  keys.push_back("note");
498  keys.push_back("nice");
499  grn_dat * const dat = create_trie(keys);
500 
501  grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
502  0, -1, GRN_CURSOR_PREFIX);
503  cut_assert_null(cursor);
504 
505  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "", 0, 0, -1,
507  cut_assert_null(cursor);
508 
509  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, -1,
511  cppcut_assert_not_null(cursor);
512  cppcut_assert_equal(static_cast<grn_id>(3),
513  grn_dat_cursor_next(&ctx, cursor));
514  cppcut_assert_equal(static_cast<grn_id>(1),
515  grn_dat_cursor_next(&ctx, cursor));
516  cppcut_assert_equal(static_cast<grn_id>(2),
517  grn_dat_cursor_next(&ctx, cursor));
518  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
519  grn_dat_cursor_next(&ctx, cursor));
520  grn_dat_cursor_close(&ctx, cursor);
521 
522  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "not", 3, 0, -1,
524  cppcut_assert_not_null(cursor);
525  cppcut_assert_equal(static_cast<grn_id>(1),
526  grn_dat_cursor_next(&ctx, cursor));
527  cppcut_assert_equal(static_cast<grn_id>(2),
528  grn_dat_cursor_next(&ctx, cursor));
529  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
530  grn_dat_cursor_next(&ctx, cursor));
531  grn_dat_cursor_close(&ctx, cursor);
532 
533  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 3, "note", 4, 0, -1,
535  cppcut_assert_not_null(cursor);
536  cppcut_assert_equal(static_cast<grn_id>(3),
537  grn_dat_cursor_next(&ctx, cursor));
538  cppcut_assert_equal(static_cast<grn_id>(1),
539  grn_dat_cursor_next(&ctx, cursor));
540  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
541  grn_dat_cursor_next(&ctx, cursor));
542  grn_dat_cursor_close(&ctx, cursor);
543 
544  cursor = grn_dat_cursor_open(&ctx, dat, "XYZ", 3, "note", 4, 0, -1,
546  cppcut_assert_not_null(cursor);
547  cppcut_assert_equal(static_cast<grn_id>(3),
548  grn_dat_cursor_next(&ctx, cursor));
549  cppcut_assert_equal(static_cast<grn_id>(1),
550  grn_dat_cursor_next(&ctx, cursor));
551  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
552  grn_dat_cursor_next(&ctx, cursor));
553  grn_dat_cursor_close(&ctx, cursor);
554 
555  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 1, -1,
557  cppcut_assert_not_null(cursor);
558  cppcut_assert_equal(static_cast<grn_id>(1),
559  grn_dat_cursor_next(&ctx, cursor));
560  cppcut_assert_equal(static_cast<grn_id>(2),
561  grn_dat_cursor_next(&ctx, cursor));
562  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
563  grn_dat_cursor_next(&ctx, cursor));
564  grn_dat_cursor_close(&ctx, cursor);
565 
566  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
568  cppcut_assert_not_null(cursor);
569  cppcut_assert_equal(static_cast<grn_id>(3),
570  grn_dat_cursor_next(&ctx, cursor));
571  cppcut_assert_equal(static_cast<grn_id>(1),
572  grn_dat_cursor_next(&ctx, cursor));
573  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
574  grn_dat_cursor_next(&ctx, cursor));
575  grn_dat_cursor_close(&ctx, cursor);
576 
577  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
579  cppcut_assert_not_null(cursor);
580  cppcut_assert_equal(static_cast<grn_id>(3),
581  grn_dat_cursor_next(&ctx, cursor));
582  cppcut_assert_equal(static_cast<grn_id>(1),
583  grn_dat_cursor_next(&ctx, cursor));
584  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
585  grn_dat_cursor_next(&ctx, cursor));
586  grn_dat_cursor_close(&ctx, cursor);
587 
588  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
590  cppcut_assert_not_null(cursor);
591  cppcut_assert_equal(static_cast<grn_id>(3),
592  grn_dat_cursor_next(&ctx, cursor));
593  cppcut_assert_equal(static_cast<grn_id>(1),
594  grn_dat_cursor_next(&ctx, cursor));
595  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
596  grn_dat_cursor_next(&ctx, cursor));
597  grn_dat_cursor_close(&ctx, cursor);
598 
599  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 2, "note", 4,
601  cppcut_assert_not_null(cursor);
602  cppcut_assert_equal(static_cast<grn_id>(3),
603  grn_dat_cursor_next(&ctx, cursor));
604  cppcut_assert_equal(static_cast<grn_id>(1),
605  grn_dat_cursor_next(&ctx, cursor));
606  cppcut_assert_equal(static_cast<grn_id>(2),
607  grn_dat_cursor_next(&ctx, cursor));
608  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
609  grn_dat_cursor_next(&ctx, cursor));
610  grn_dat_cursor_close(&ctx, cursor);
611 
612  cursor = grn_dat_cursor_open(&ctx, dat, NULL, 2, "note", 4,
614  cppcut_assert_not_null(cursor);
615  cppcut_assert_equal(static_cast<grn_id>(3),
616  grn_dat_cursor_next(&ctx, cursor));
617  cppcut_assert_equal(static_cast<grn_id>(1),
618  grn_dat_cursor_next(&ctx, cursor));
619  cppcut_assert_equal(static_cast<grn_id>(2),
620  grn_dat_cursor_next(&ctx, cursor));
621  cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
622  grn_dat_cursor_next(&ctx, cursor));
623  grn_dat_cursor_close(&ctx, cursor);
624 
626  }
627 }