Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / test / fts4unicode.test
blobf237119a1871b250da71515ad124aa2de706f19d
1 # 2012 May 25
3 # The author disclaims copyright to this source code.  In place of
4 # a legal notice, here is a blessing:
6 #    May you do good and not evil.
7 #    May you find forgiveness for yourself and forgive others.
8 #    May you share freely, never taking more than you give.
10 #*************************************************************************
12 # The tests in this file focus on testing the "unicode" FTS tokenizer.
15 set testdir [file dirname $argv0]
16 source $testdir/tester.tcl
17 ifcapable !fts3_unicode { finish_test ; return }
18 set ::testprefix fts4unicode
20 proc do_unicode_token_test {tn input res} {
21   set input [string map {' ''} $input]
22   uplevel [list do_execsql_test $tn "
23     SELECT fts3_tokenizer_test('unicode61', 'remove_diacritics=0', '$input');
24   " [list [list {*}$res]]]
27 proc do_unicode_token_test2 {tn input res} {
28   set input [string map {' ''} $input]
29   uplevel [list do_execsql_test $tn "
30     SELECT fts3_tokenizer_test('unicode61', '$input');
31   " [list [list {*}$res]]]
34 proc do_unicode_token_test3 {tn args} {
35   set res   [lindex $args end]
36   set sql "SELECT fts3_tokenizer_test('unicode61'"
37   foreach a [lrange $args 0 end-1] {
38     append sql ", '"
39     append sql [string map {' ''} $a]
40     append sql "'"
41   }
42   append sql ")"
43   uplevel [list do_execsql_test $tn $sql [list [list {*}$res]]]
46 do_unicode_token_test 1.0 {a B c D} {0 a a 1 b B 2 c c 3 d D}
48 do_unicode_token_test 1.1 "\uC4 \uD6 \uDC" \
49     "0 \uE4 \uC4 1 \uF6 \uD6 2 \uFC \uDC"
51 do_unicode_token_test 1.2 "x\uC4x x\uD6x x\uDCx" \
52     "0 x\uE4x x\uC4x 1 x\uF6x x\uD6x 2 x\uFCx x\uDCx"
54 # 0x00DF is a small "sharp s". 0x1E9E is a capital sharp s.
55 do_unicode_token_test 1.3 "\uDF" "0 \uDF \uDF"
56 do_unicode_token_test 1.4 "\u1E9E" "0 \uDF \u1E9E"
58 do_unicode_token_test 1.5 "The quick brown fox" {
59   0 the The 1 quick quick 2 brown brown 3 fox fox
61 do_unicode_token_test 1.6 "The\u00bfquick\u224ebrown\u2263fox" {
62   0 the The 1 quick quick 2 brown brown 3 fox fox
65 do_unicode_token_test2 1.7  {a B c D} {0 a a 1 b B 2 c c 3 d D}
66 do_unicode_token_test2 1.8  "\uC4 \uD6 \uDC" "0 a \uC4 1 o \uD6 2 u \uDC"
68 do_unicode_token_test2 1.9  "x\uC4x x\uD6x x\uDCx" \
69     "0 xax x\uC4x 1 xox x\uD6x 2 xux x\uDCx"
71 # Check that diacritics are removed if remove_diacritics=1 is specified.
72 # And that they do not break tokens.
73 do_unicode_token_test2 1.10 "xx\u0301xx" "0 xxxx xx\u301xx"
75 # Title-case mappings work
76 do_unicode_token_test 1.11 "\u01c5" "0 \u01c6 \u01c5"
78 #-------------------------------------------------------------------------
80 set docs [list {
81   Enhance the INSERT syntax to allow multiple rows to be inserted via the
82   VALUES clause.
83 } {
84   Enhance the CREATE VIRTUAL TABLE command to support the IF NOT EXISTS clause.
85 } {
86   Added the sqlite3_stricmp() interface as a counterpart to sqlite3_strnicmp().
87 } {
88   Added the sqlite3_db_readonly() interface.
89 } {
90   Added the SQLITE_FCNTL_PRAGMA file control, giving VFS implementations the
91   ability to add new PRAGMA statements or to override built-in PRAGMAs.  
92 } {
93   Queries of the form: "SELECT max(x), y FROM table" returns the value of y on
94   the same row that contains the maximum x value.
95 } {
96   Added support for the FTS4 languageid option.
97 } {
98   Documented support for the FTS4 content option. This feature has actually
99   been in the code since version 3.7.9 but is only now considered to be
100   officially supported.  
101 } {
102   Pending statements no longer block ROLLBACK. Instead, the pending statement
103   will return SQLITE_ABORT upon next access after the ROLLBACK.  
104 } {
105   Improvements to the handling of CSV inputs in the command-line shell
106 } {
107   Fix a bug introduced in version 3.7.10 that might cause a LEFT JOIN to be
108   incorrectly converted into an INNER JOIN if the WHERE clause indexable terms
109   connected by OR.  
112 set map(a) [list "\u00C4" "\u00E4"]  ; # LATIN LETTER A WITH DIAERESIS
113 set map(e) [list "\u00CB" "\u00EB"]  ; # LATIN LETTER E WITH DIAERESIS
114 set map(i) [list "\u00CF" "\u00EF"]  ; # LATIN LETTER I WITH DIAERESIS
115 set map(o) [list "\u00D6" "\u00F6"]  ; # LATIN LETTER O WITH DIAERESIS
116 set map(u) [list "\u00DC" "\u00FC"]  ; # LATIN LETTER U WITH DIAERESIS
117 set map(y) [list "\u0178" "\u00FF"]  ; # LATIN LETTER Y WITH DIAERESIS
118 set map(h) [list "\u1E26" "\u1E27"]  ; # LATIN LETTER H WITH DIAERESIS
119 set map(w) [list "\u1E84" "\u1E85"]  ; # LATIN LETTER W WITH DIAERESIS
120 set map(x) [list "\u1E8C" "\u1E8D"]  ; # LATIN LETTER X WITH DIAERESIS
121 foreach k [array names map] {
122   lappend mappings [string toupper $k] [lindex $map($k) 0] 
123   lappend mappings $k [lindex $map($k) 1]
125 proc mapdoc {doc} { 
126   set doc [regsub -all {[[:space:]]+} $doc " "]
127   string map $::mappings [string trim $doc] 
130 do_test 2.0 {
131   execsql { CREATE VIRTUAL TABLE t2 USING fts4(tokenize=unicode61, x); }
132   foreach doc $docs {
133     set d [mapdoc $doc]
134     execsql { INSERT INTO t2 VALUES($d) }
135   }
136 } {}
138 do_test 2.1 {
139   set q [mapdoc "row"]
140   execsql { SELECT * FROM t2 WHERE t2 MATCH $q }
141 } [list [mapdoc {
142   Queries of the form: "SELECT max(x), y FROM table" returns the value of y on
143   the same row that contains the maximum x value.
146 foreach {tn query snippet} {
147   2 "row" {
148      ...returns the value of y on the same [row] that contains 
149      the maximum x value.
150   }
151   3 "ROW" {
152      ...returns the value of y on the same [row] that contains 
153      the maximum x value.
154   }
155   4 "rollback" {
156      ...[ROLLBACK]. Instead, the pending statement
157      will return SQLITE_ABORT upon next access after the [ROLLBACK].
158   }
159   5 "rOllback" {
160      ...[ROLLBACK]. Instead, the pending statement
161      will return SQLITE_ABORT upon next access after the [ROLLBACK].
162   }
163   6 "lang*" {
164      Added support for the FTS4 [languageid] option.
165   }
166 } {
167   do_test 2.$tn {
168     set q [mapdoc $query]
169     execsql { SELECT snippet(t2, '[', ']', '...') FROM t2 WHERE t2 MATCH $q }
170   } [list [mapdoc $snippet]]
173 #-------------------------------------------------------------------------
174 # Make sure the unicode61 tokenizer does not crash if it is passed a 
175 # NULL pointer.
176 reset_db
177 do_execsql_test 3.1 {
178   CREATE VIRTUAL TABLE t1 USING fts4(tokenize=unicode61, x, y);
179   INSERT INTO t1 VALUES(NULL, 'a b c');
182 do_execsql_test 3.2 {
183   SELECT snippet(t1, '[', ']') FROM t1 WHERE t1 MATCH 'b'
184 } {{a [b] c}}
186 do_execsql_test 3.3 {
187   BEGIN;
188   DELETE FROM t1;
189   INSERT INTO t1 VALUES('b b b b b b b b b b b', 'b b b b b b b b b b b b b');
190   INSERT INTO t1 SELECT * FROM t1;
191   INSERT INTO t1 SELECT * FROM t1;
192   INSERT INTO t1 SELECT * FROM t1;
193   INSERT INTO t1 SELECT * FROM t1;
194   INSERT INTO t1 SELECT * FROM t1;
195   INSERT INTO t1 SELECT * FROM t1;
196   INSERT INTO t1 SELECT * FROM t1;
197   INSERT INTO t1 SELECT * FROM t1;
198   INSERT INTO t1 SELECT * FROM t1;
199   INSERT INTO t1 SELECT * FROM t1;
200   INSERT INTO t1 SELECT * FROM t1;
201   INSERT INTO t1 SELECT * FROM t1;
202   INSERT INTO t1 SELECT * FROM t1;
203   INSERT INTO t1 SELECT * FROM t1;
204   INSERT INTO t1 SELECT * FROM t1;
205   INSERT INTO t1 SELECT * FROM t1;
206   INSERT INTO t1 VALUES('a b c', NULL);
207   INSERT INTO t1 VALUES('a x c', NULL);
208   COMMIT;
211 do_execsql_test 3.4 {
212   SELECT * FROM t1 WHERE t1 MATCH 'a b';
213 } {{a b c} {}}
215 #-------------------------------------------------------------------------
217 reset_db
219 do_test 4.1 {
220   set a "abc\uFFFEdef"
221   set b "abc\uD800def"
222   set c "\uFFFEdef"
223   set d "\uD800def"
224   execsql {
225     CREATE VIRTUAL TABLE t1 USING fts4(tokenize=unicode61, x);
226     INSERT INTO t1 VALUES($a);
227     INSERT INTO t1 VALUES($b);
228     INSERT INTO t1 VALUES($c);
229     INSERT INTO t1 VALUES($d);
230   }
231 } {}
233 do_test 4.2 {
234   set a [binary format c* {0x61 0xF7 0xBF 0xBF 0xBF 0x62}]
235   set b [binary format c* {0x61 0xF7 0xBF 0xBF 0xBF 0xBF 0x62}]
236   set c [binary format c* {0x61 0xF7 0xBF 0xBF 0xBF 0xBF 0xBF 0x62}]
237   set d [binary format c* {0x61 0xF7 0xBF 0xBF 0xBF 0xBF 0xBF 0xBF 0x62}]
238   execsql {
239     INSERT INTO t1 VALUES($a);
240     INSERT INTO t1 VALUES($b);
241     INSERT INTO t1 VALUES($c);
242     INSERT INTO t1 VALUES($d);
243   }
244 } {}
246 do_test 4.3 {
247   set a [binary format c* {0xF7 0xBF 0xBF 0xBF}]
248   set b [binary format c* {0xF7 0xBF 0xBF 0xBF 0xBF}]
249   set c [binary format c* {0xF7 0xBF 0xBF 0xBF 0xBF 0xBF}]
250   set d [binary format c* {0xF7 0xBF 0xBF 0xBF 0xBF 0xBF 0xBF}]
251   execsql {
252     INSERT INTO t1 VALUES($a);
253     INSERT INTO t1 VALUES($b);
254     INSERT INTO t1 VALUES($c);
255     INSERT INTO t1 VALUES($d);
256   }
257 } {}
259 #-------------------------------------------------------------------------
261 do_unicode_token_test3 5.1 {tokenchars=} {
262   sqlite3_reset sqlite3_column_int
263 } {
264   0 sqlite3 sqlite3 
265   1 reset reset 
266   2 sqlite3 sqlite3 
267   3 column column 
268   4 int int
271 do_unicode_token_test3 5.2 {tokenchars=_} {
272   sqlite3_reset sqlite3_column_int
273 } {
274   0 sqlite3_reset sqlite3_reset 
275   1 sqlite3_column_int sqlite3_column_int
278 do_unicode_token_test3 5.3 {separators=xyz} {
279   Laotianxhorseyrunszfast
280 } {
281   0 laotian Laotian
282   1 horse horse
283   2 runs runs
284   3 fast fast
287 do_unicode_token_test3 5.4 {tokenchars=xyz} {
288   Laotianxhorseyrunszfast
289 } {
290   0 laotianxhorseyrunszfast Laotianxhorseyrunszfast
293 do_unicode_token_test3 5.5 {tokenchars=_} {separators=zyx} {
294   sqlite3_resetxsqlite3_column_intyhonda_phantom
295 } {
296   0 sqlite3_reset sqlite3_reset 
297   1 sqlite3_column_int sqlite3_column_int
298   2 honda_phantom honda_phantom
301 do_unicode_token_test3 5.6 "separators=\u05D1" "abc\u05D1def" {
302   0 abc abc 1 def def
305 do_unicode_token_test3 5.7                             \
306   "tokenchars=\u2444\u2445"                            \
307   "separators=\u05D0\u05D1\u05D2"                      \
308   "\u2444fre\u2445sh\u05D0water\u05D2fish.\u2445timer" \
309   [list                                                \
310     0 \u2444fre\u2445sh \u2444fre\u2445sh              \
311     1 water water                                      \
312     2 fish fish                                        \
313     3 \u2445timer \u2445timer                          \
314   ]
316 # Check that it is not possible to add a standalone diacritic codepoint 
317 # to either separators or tokenchars.
318 do_unicode_token_test3 5.8 "separators=\u0301" \
319   "hello\u0301world \u0301helloworld"          \
320   "0 helloworld hello\u0301world 1 helloworld helloworld"
322 do_unicode_token_test3 5.9 "tokenchars=\u0301" \
323   "hello\u0301world \u0301helloworld"          \
324   "0 helloworld hello\u0301world 1 helloworld helloworld"
326 do_unicode_token_test3 5.10 "separators=\u0301" \
327   "remove_diacritics=0"                        \
328   "hello\u0301world \u0301helloworld"          \
329   "0 hello\u0301world hello\u0301world 1 helloworld helloworld"
331 do_unicode_token_test3 5.11 "tokenchars=\u0301" \
332   "remove_diacritics=0"                         \
333   "hello\u0301world \u0301helloworld"           \
334   "0 hello\u0301world hello\u0301world 1 helloworld helloworld"
337 #-------------------------------------------------------------------------
339 proc do_tokenize {tokenizer txt} {
340   set res [list]
341   foreach {a b c} [db one {SELECT fts3_tokenizer_test($tokenizer, $txt)}] {
342     lappend res $b
343   }
344   set res
347 # Argument $lCodepoint must be a list of codepoints (integers) that 
348 # correspond to whitespace characters. This command creates a string
349 # $W from the codepoints, then tokenizes "${W}hello{$W}world${W}" 
350 # using tokenizer $tokenizer. The test passes if the tokenizer successfully
351 # extracts the two 5 character tokens.
353 proc do_isspace_test {tn tokenizer lCp} {
354   set whitespace [format [string repeat %c [llength $lCp]] {*}$lCp] 
355   set txt "${whitespace}hello${whitespace}world${whitespace}"
356   uplevel [list do_test $tn [list do_tokenize $tokenizer $txt] {hello world}]
359 set tokenizers [list unicode61]
360 ifcapable icu { lappend tokenizers icu }
362 # Some tests to check that the tokenizers can both identify white-space 
363 # codepoints. All codepoints tested below are of type "Zs" in the
364 # UnicodeData.txt file.
365 foreach T $tokenizers {
366   do_isspace_test 6.$T.1 $T    32
367   do_isspace_test 6.$T.2 $T    160
368   do_isspace_test 6.$T.3 $T    5760
369   do_isspace_test 6.$T.4 $T    6158
370   do_isspace_test 6.$T.5 $T    8192
371   do_isspace_test 6.$T.6 $T    8193
372   do_isspace_test 6.$T.7 $T    8194
373   do_isspace_test 6.$T.8 $T    8195
374   do_isspace_test 6.$T.9 $T    8196
375   do_isspace_test 6.$T.10 $T    8197
376   do_isspace_test 6.$T.11 $T    8198
377   do_isspace_test 6.$T.12 $T    8199
378   do_isspace_test 6.$T.13 $T    8200
379   do_isspace_test 6.$T.14 $T    8201
380   do_isspace_test 6.$T.15 $T    8202
381   do_isspace_test 6.$T.16 $T    8239
382   do_isspace_test 6.$T.17 $T    8287
383   do_isspace_test 6.$T.18 $T   12288
385   do_isspace_test 6.$T.19 $T   {32 160 5760 6158}
386   do_isspace_test 6.$T.20 $T   {8192 8193 8194 8195}
387   do_isspace_test 6.$T.21 $T   {8196 8197 8198 8199}
388   do_isspace_test 6.$T.22 $T   {8200 8201 8202 8239}
389   do_isspace_test 6.$T.23 $T   {8287 12288}
392 #-------------------------------------------------------------------------
393 # Test that the private use ranges are treated as alphanumeric.
395 foreach {tn1 c} {
396   1 \ue000 2 \ue001 3 \uf000 4 \uf8fe 5 \uf8ff
397 } {
398   foreach {tn2 config res} {
399     1 ""             "0 hello*world hello*world"
400     2 "separators=*" "0 hello hello 1 world world"
401   } {
402     set config [string map [list * $c] $config]
403     set input  [string map [list * $c] "hello*world"]
404     set output [string map [list * $c] $res]
405     do_unicode_token_test3 7.$tn1.$tn2 {*}$config $input $output
406   }
409 #-------------------------------------------------------------------------
410 # Cursory test of remove_diacritics=0.
412 # 00C4;LATIN CAPITAL LETTER A WITH DIAERESIS
413 # 00D6;LATIN CAPITAL LETTER O WITH DIAERESIS
414 # 00E4;LATIN SMALL LETTER A WITH DIAERESIS
415 # 00F6;LATIN SMALL LETTER O WITH DIAERESIS
417 do_execsql_test 8.1.1 "
418   CREATE VIRTUAL TABLE t3 USING fts4(tokenize=unicode61 'remove_diacritics=1');
419   INSERT INTO t3 VALUES('o');
420   INSERT INTO t3 VALUES('a');
421   INSERT INTO t3 VALUES('O');
422   INSERT INTO t3 VALUES('A');
423   INSERT INTO t3 VALUES('\xD6');
424   INSERT INTO t3 VALUES('\xC4');
425   INSERT INTO t3 VALUES('\xF6');
426   INSERT INTO t3 VALUES('\xE4');
428 do_execsql_test 8.1.2 {
429   SELECT rowid FROM t3 WHERE t3 MATCH 'o';
430 } {1 3 5 7}
431 do_execsql_test 8.1.3 {
432   SELECT rowid FROM t3 WHERE t3 MATCH 'a';
433 } {2 4 6 8}
434 do_execsql_test 8.2.1 {
435   CREATE VIRTUAL TABLE t4 USING fts4(tokenize=unicode61 "remove_diacritics=0");
436   INSERT INTO t4 SELECT * FROM t3;
438 do_execsql_test 8.2.2 {
439   SELECT rowid FROM t4 WHERE t4 MATCH 'o';
440 } {1 3}
441 do_execsql_test 8.2.3 {
442   SELECT rowid FROM t4 WHERE t4 MATCH 'a';
443 } {2 4}
445 #-------------------------------------------------------------------------
447 foreach {tn sql} {
448   1 {
449     CREATE VIRTUAL TABLE t5 USING fts4(tokenize=unicode61 [tokenchars= .]);
450     CREATE VIRTUAL TABLE t6 USING fts4(
451         tokenize=unicode61 [tokenchars=="] "tokenchars=[]");
452     CREATE VIRTUAL TABLE t7 USING fts4(tokenize=unicode61 [separators=x\xC4]);
453   }
454   2 {
455     CREATE VIRTUAL TABLE t5 USING fts4(tokenize=unicode61 "tokenchars= .");
456     CREATE VIRTUAL TABLE t6 USING fts4(tokenize=unicode61 "tokenchars=[=""]");
457     CREATE VIRTUAL TABLE t7 USING fts4(tokenize=unicode61 "separators=x\xC4");
458   }
459   3 {
460     CREATE VIRTUAL TABLE t5 USING fts4(tokenize=unicode61 'tokenchars= .');
461     CREATE VIRTUAL TABLE t6 USING fts4(tokenize=unicode61 'tokenchars=="[]');
462     CREATE VIRTUAL TABLE t7 USING fts4(tokenize=unicode61 'separators=x\xC4');
463   }
464   4 {
465     CREATE VIRTUAL TABLE t5 USING fts4(tokenize=unicode61 `tokenchars= .`);
466     CREATE VIRTUAL TABLE t6 USING fts4(tokenize=unicode61 `tokenchars=[="]`);
467     CREATE VIRTUAL TABLE t7 USING fts4(tokenize=unicode61 `separators=x\xC4`);
468   }
469 } {
470   do_execsql_test 9.$tn.0 { 
471     DROP TABLE IF EXISTS t5;
472     DROP TABLE IF EXISTS t5aux;
473     DROP TABLE IF EXISTS t6;
474     DROP TABLE IF EXISTS t6aux;
475     DROP TABLE IF EXISTS t7;
476     DROP TABLE IF EXISTS t7aux;
477   }
478   do_execsql_test 9.$tn.1 $sql
480   do_execsql_test 9.$tn.2 {
481     CREATE VIRTUAL TABLE t5aux USING fts4aux(t5);
482     INSERT INTO t5 VALUES('one two three/four.five.six');
483     SELECT * FROM t5aux;
484   } {
485     four.five.six   * 1 1 four.five.six   0 1 1 
486     {one two three} * 1 1 {one two three} 0 1 1
487   }
489   do_execsql_test 9.$tn.3 {
490     CREATE VIRTUAL TABLE t6aux USING fts4aux(t6);
491     INSERT INTO t6 VALUES('alpha=beta"gamma/delta[epsilon]zeta');
492     SELECT * FROM t6aux;
493   } {
494     {alpha=beta"gamma}   * 1 1 {alpha=beta"gamma} 0 1 1 
495     {delta[epsilon]zeta} * 1 1 {delta[epsilon]zeta} 0 1 1
496   }
498   do_execsql_test 9.$tn.4 {
499     CREATE VIRTUAL TABLE t7aux USING fts4aux(t7);
500     INSERT INTO t7 VALUES('alephxbeth\xC4gimel');
501     SELECT * FROM t7aux;
502   } {
503     aleph * 1 1 aleph 0 1 1 
504     beth  * 1 1 beth  0 1 1 
505     gimel * 1 1 gimel 0 1 1
506   }
509 # Check that multiple options are handled correctly.
511 do_execsql_test 10.1 {
512   DROP TABLE IF EXISTS t1;
513   CREATE VIRTUAL TABLE t1 USING fts4(tokenize=unicode61
514     "tokenchars=xyz" "tokenchars=.=" "separators=.=" "separators=xy"
515     "separators=a" "separators=a" "tokenchars=a" "tokenchars=a"
516   );
518   INSERT INTO t1 VALUES('oneatwoxthreeyfour');
519   INSERT INTO t1 VALUES('a.single=word');
520   CREATE VIRTUAL TABLE t1aux USING fts4aux(t1);
521   SELECT * FROM t1aux;
522 } {
523   .single=word * 1 1 .single=word 0 1 1 
524   four         * 1 1 four         0 1 1 
525   one          * 1 1 one          0 1 1 
526   three        * 1 1 three        0 1 1 
527   two          * 1 1 two          0 1 1
530 # Test that case folding happens after tokenization, not before.
532 do_execsql_test 10.2 {
533   DROP TABLE IF EXISTS t2;
534   CREATE VIRTUAL TABLE t2 USING fts4(tokenize=unicode61 "separators=aB");
535   INSERT INTO t2 VALUES('oneatwoBthree');
536   INSERT INTO t2 VALUES('onebtwoAthree');
537   CREATE VIRTUAL TABLE t2aux USING fts4aux(t2);
538   SELECT * FROM t2aux;
539 } {
540   one           * 1 1 one           0 1 1 
541   onebtwoathree * 1 1 onebtwoathree 0 1 1 
542   three         * 1 1 three         0 1 1 
543   two           * 1 1 two           0 1 1
546 # Test that the tokenchars and separators options work with the 
547 # fts3tokenize table.
549 do_execsql_test 11.1 {
550   CREATE VIRTUAL TABLE ft1 USING fts3tokenize(
551     "unicode61", "tokenchars=@.", "separators=1234567890"
552   );
553   SELECT token FROM ft1 WHERE input = 'berlin@street123sydney.road';
554 } {
555   berlin@street sydney.road
558 finish_test