lib/Lucy/Test.xs

filter: Statementstmt 2.3% 24 / 1021 Branchbran 1.9% 4 / 204 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 2.2% 28 / 1225 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« autogen/include/Lucy/Index/SortCache.h ↑ Summary lib/Lucy.xs »
1 /*
2 * ***********************************************
3 *
4 * !!!! DO NOT EDIT !!!!
5 *
6 * This file was auto-generated by Build.PL.
7 *
8 * ***********************************************
9 *
10 * Licensed to the Apache Software Foundation (ASF) under one or more
11 * contributor license agreements. See the NOTICE file distributed with
12 * this work for additional information regarding copyright ownership.
13 * The ASF licenses this file to You under the Apache License, Version 2.0
14 * (the "License"); you may not use this file except in compliance with
15 * the License. You may obtain a copy of the License at
16 *
17 * http://www.apache.org/licenses/LICENSE-2.0
18 *
19 * Unless required by applicable law or agreed to in writing, software
20 * distributed under the License is distributed on an "AS IS" BASIS,
21 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 * See the License for the specific language governing permissions and
23 * limitations under the License.
24 */
25  
26 #define CFP_TESTLUCY
27  
28 #include "XSBind.h"
29 #include "testlucy_perl.h"
30 #include "Lucy/Test/Store/MockFileHandle.h"
31 #include "Lucy/Test.h"
32 #include "Lucy/Test/Analysis/TestAnalyzer.h"
33 #include "Lucy/Test/Analysis/TestAnalyzer.h"
34 #include "Lucy/Test/Analysis/TestCaseFolder.h"
35 #include "Lucy/Test/Analysis/TestNormalizer.h"
36 #include "Lucy/Test/Analysis/TestPolyAnalyzer.h"
37 #include "Lucy/Test/Analysis/TestRegexTokenizer.h"
38 #include "Lucy/Test/Analysis/TestSnowballStemmer.h"
39 #include "Lucy/Test/Analysis/TestSnowballStopFilter.h"
40 #include "Lucy/Test/Analysis/TestStandardTokenizer.h"
41 #include "Lucy/Test/Highlight/TestHeatMap.h"
42 #include "Lucy/Test/Highlight/TestHighlighter.h"
43 #include "Lucy/Test/Index/NoMergeManager.h"
44 #include "Lucy/Test/Index/TestBackgroundMerger.h"
45 #include "Lucy/Test/Index/TestDocWriter.h"
46 #include "Lucy/Test/Index/TestHighlightWriter.h"
47 #include "Lucy/Test/Index/TestIndexManager.h"
48 #include "Lucy/Test/Index/TestPolyReader.h"
49 #include "Lucy/Test/Index/TestPostingListWriter.h"
50 #include "Lucy/Test/Index/TestSegWriter.h"
51 #include "Lucy/Test/Index/TestSegment.h"
52 #include "Lucy/Test/Index/TestSnapshot.h"
53 #include "Lucy/Test/Index/TestSortWriter.h"
54 #include "Lucy/Test/Index/TestTermInfo.h"
55 #include "Lucy/Test/Object/TestBitVector.h"
56 #include "Lucy/Test/Object/TestI32Array.h"
57 #include "Lucy/Test/Plan/TestFieldType.h"
58 #include "Lucy/Test/Plan/TestArchitecture.h"
59 #include "Lucy/Test/Plan/TestBlobType.h"
60 #include "Lucy/Test/Plan/TestFieldMisc.h"
61 #include "Lucy/Test/Plan/TestFieldType.h"
62 #include "Lucy/Test/Plan/TestFullTextType.h"
63 #include "Lucy/Test/Plan/TestNumericType.h"
64 #include "Lucy/Test/Search/TestPolyQuery.h"
65 #include "Lucy/Test/Search/TestLeafQuery.h"
66 #include "Lucy/Test/Search/TestMatchAllQuery.h"
67 #include "Lucy/Test/Search/TestNOTQuery.h"
68 #include "Lucy/Test/Search/TestNoMatchQuery.h"
69 #include "Lucy/Test/Search/TestPolyQuery.h"
70 #include "Lucy/Test/Search/TestPhraseQuery.h"
71 #include "Lucy/Test/Search/TestPolySearcher.h"
72 #include "Lucy/Test/Search/TestQueryParser.h"
73 #include "Lucy/Test/Search/TestQueryParserLogic.h"
74 #include "Lucy/Test/Search/TestQueryParserSyntax.h"
75 #include "Lucy/Test/Search/TestRangeQuery.h"
76 #include "Lucy/Test/Search/TestReqOptQuery.h"
77 #include "Lucy/Test/Search/TestSortSpec.h"
78 #include "Lucy/Test/Search/TestSeriesMatcher.h"
79 #include "Lucy/Test/Search/TestSortSpec.h"
80 #include "Lucy/Test/Search/TestSpan.h"
81 #include "Lucy/Test/Search/TestTermQuery.h"
82 #include "Lucy/Test/Store/TestCompoundFileReader.h"
83 #include "Lucy/Test/Store/TestCompoundFileWriter.h"
84 #include "Lucy/Test/Store/TestFSDirHandle.h"
85 #include "Lucy/Test/Store/TestFSFileHandle.h"
86 #include "Lucy/Test/Store/TestFSFolder.h"
87 #include "Lucy/Test/Store/TestFileHandle.h"
88 #include "Lucy/Test/Store/TestFolder.h"
89 #include "Lucy/Test/Store/TestFolderCommon.h"
90 #include "Lucy/Test/Store/TestIOChunks.h"
91 #include "Lucy/Test/Store/TestIOPrimitives.h"
92 #include "Lucy/Test/Store/TestInStream.h"
93 #include "Lucy/Test/Store/TestLock.h"
94 #include "Lucy/Test/Store/TestRAMDirHandle.h"
95 #include "Lucy/Test/Store/TestRAMFileHandle.h"
96 #include "Lucy/Test/Store/TestRAMFolder.h"
97 #include "Lucy/Test/TestSchema.h"
98 #include "Lucy/Test/TestSchema.h"
99 #include "Lucy/Test/TestSimple.h"
100 #include "Lucy/Test/TestUtils.h"
101 #include "Lucy/Test/Util/TestPriorityQueue.h"
102 #include "Lucy/Test/Util/TestFreezer.h"
103 #include "Lucy/Test/Util/TestIndexFileNames.h"
104 #include "Lucy/Test/Util/TestJson.h"
105 #include "Lucy/Test/Util/TestMemoryPool.h"
106 #include "Lucy/Test/Util/TestNumberUtils.h"
107 #include "Lucy/Test/Util/TestPriorityQueue.h"
108 #include "Lucy/Test/Util/TestSortExternal.h"
109 #include "Lucy/Test/Util/TestStringHelper.h"
110  
111 #ifndef XS_INTERNAL
112 #define XS_INTERNAL XS
113 #endif
114  
115 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_new);
116 0 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_new) {
117 0 dXSARGS;
118 static const XSBind_ParamSpec param_specs[2] = {
119 XSBIND_PARAM("path", 0),
120 XSBIND_PARAM("length", 1)
121 };
122 int32_t locations[2];
123 SV *sv;
124 testlucy_MockFileHandle* arg_self;
125 cfish_String* arg_path;
126 int64_t arg_length;
127 testlucy_MockFileHandle* retval;
128  
129 CFISH_UNUSED_VAR(cv);
130 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
131 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
132 }
133 0 SP -= items;
134  
135 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
136 locations, 2);
137 0 sv = ST(locations[0]);
138 0 ▶ arg_path = locations[0] < items ? (cfish_String*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "path", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL;
Branch: 1 branch
BranchTrueFalseTotal
arg_path = locations[0] < items ? (cfish_String*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "path", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL; 0 0 0
139 0 sv = ST(locations[1]);
140 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
141 0 XSBind_undef_arg_error(aTHX_ "length");
142 }
143 0 arg_length = (int64_t)SvNV(sv);
144 0 arg_self = (testlucy_MockFileHandle*)XSBind_new_blank_obj(aTHX_ ST(0));
145  
146 0 retval = testlucy_MockFileHandle_init(arg_self, arg_path, arg_length);
147 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
148 0 XSRETURN(1);
149 }
150  
151  
152 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_window);
153 0 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_window) {
154 0 dXSARGS;
155 static const XSBind_ParamSpec param_specs[3] = {
156 XSBIND_PARAM("window", 1),
157 XSBIND_PARAM("offset", 1),
158 XSBIND_PARAM("len", 1)
159 };
160 int32_t locations[3];
161 SV *sv;
162 testlucy_MockFileHandle* arg_self;
163 lucy_FileWindow* arg_window;
164 int64_t arg_offset;
165 int64_t arg_len;
166 TESTLUCY_MockFileHandle_Window_t method;
167 bool retval;
168  
169 CFISH_UNUSED_VAR(cv);
170 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
171 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
172 }
173 0 SP -= items;
174  
175 /* Locate args on Perl stack. */
176 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
177 locations, 3);
178 0 arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
179 0 sv = ST(locations[0]);
180 0 arg_window = (lucy_FileWindow*)XSBind_arg_to_cfish(aTHX_ sv, "window", LUCY_FILEWINDOW, NULL);
181 0 sv = ST(locations[1]);
182 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
183 0 XSBind_undef_arg_error(aTHX_ "offset");
184 }
185 0 arg_offset = (int64_t)SvNV(sv);
186 0 sv = ST(locations[2]);
187 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
188 0 XSBind_undef_arg_error(aTHX_ "len");
189 }
190 0 arg_len = (int64_t)SvNV(sv);
191  
192 /* Execute */
193 0 method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Window);
194 0 retval = method(arg_self, arg_window, arg_offset, arg_len);
195 0 ST(0) = newSViv(!!retval);
196 0 sv_2mortal( ST(0) );
197 0 XSRETURN(1);
198 }
199  
200 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_release_window);
201 0 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_release_window) {
202 0 dXSARGS;
203 SV *sv;
204 testlucy_MockFileHandle* arg_self;
205 lucy_FileWindow* arg_window;
206 TESTLUCY_MockFileHandle_Release_Window_t method;
207 bool retval;
208  
209 CFISH_UNUSED_VAR(cv);
210 0 SP -= items;
211 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
212 0 XSBind_invalid_args_error(aTHX_ cv, "self, window");
213 }
214  
215 /* Extract vars from Perl stack. */
216 0 arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
217 0 sv = ST(1);
218 0 arg_window = (lucy_FileWindow*)XSBind_arg_to_cfish(aTHX_ sv, "window", LUCY_FILEWINDOW, NULL);
219  
220 /* Execute */
221 0 method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Release_Window);
222 0 retval = method(arg_self, arg_window);
223 0 ST(0) = newSViv(!!retval);
224 0 sv_2mortal( ST(0) );
225 0 XSRETURN(1);
226 }
227  
228 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_length);
229 0 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_length) {
230 0 dXSARGS;
231 testlucy_MockFileHandle* arg_self;
232 TESTLUCY_MockFileHandle_Length_t method;
233 int64_t retval;
234  
235 CFISH_UNUSED_VAR(cv);
236 0 SP -= items;
237 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
238 0 XSBind_invalid_args_error(aTHX_ cv, "self");
239 }
240  
241 /* Extract vars from Perl stack. */
242 0 arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
243  
244 /* Execute */
245 0 method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Length);
246 0 retval = method(arg_self);
247 0 ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
248 0 sv_2mortal( ST(0) );
249 0 XSRETURN(1);
250 }
251  
252 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_close);
253 0 XS_INTERNAL(XS_Lucy_Store_MockFileHandle_close) {
254 0 dXSARGS;
255 testlucy_MockFileHandle* arg_self;
256 TESTLUCY_MockFileHandle_Close_t method;
257 bool retval;
258  
259 CFISH_UNUSED_VAR(cv);
260 0 SP -= items;
261 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
262 0 XSBind_invalid_args_error(aTHX_ cv, "self");
263 }
264  
265 /* Extract vars from Perl stack. */
266 0 arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
267  
268 /* Execute */
269 0 method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Close);
270 0 retval = method(arg_self);
271 0 ST(0) = newSViv(!!retval);
272 0 sv_2mortal( ST(0) );
273 0 XSRETURN(1);
274 }
275  
276 XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_new);
277 0 XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_new) {
278 0 dXSARGS;
279 testlucy_DummyAnalyzer* arg_self;
280 testlucy_DummyAnalyzer* retval;
281  
282 CFISH_UNUSED_VAR(cv);
283 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
284 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
285 }
286 0 SP -= items;
287  
288 0 arg_self = (testlucy_DummyAnalyzer*)XSBind_new_blank_obj(aTHX_ ST(0));
289  
290 0 retval = testlucy_DummyAnalyzer_init(arg_self);
291 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
292 0 XSRETURN(1);
293 }
294  
295  
296 XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_transform);
297 0 XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_transform) {
298 0 dXSARGS;
299 SV *sv;
300 testlucy_DummyAnalyzer* arg_self;
301 lucy_Inversion* arg_inversion;
302 TESTLUCY_DummyAnalyzer_Transform_t method;
303 lucy_Inversion* retval;
304  
305 CFISH_UNUSED_VAR(cv);
306 0 SP -= items;
307 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
308 0 XSBind_invalid_args_error(aTHX_ cv, "self, inversion");
309 }
310  
311 /* Extract vars from Perl stack. */
312 0 arg_self = (testlucy_DummyAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_DUMMYANALYZER, NULL);
313 0 sv = ST(1);
314 0 arg_inversion = (lucy_Inversion*)XSBind_arg_to_cfish(aTHX_ sv, "inversion", LUCY_INVERSION, NULL);
315  
316 /* Execute */
317 0 method = CFISH_METHOD_PTR(TESTLUCY_DUMMYANALYZER, TESTLUCY_DummyAnalyzer_Transform);
318 0 retval = method(arg_self, arg_inversion);
319 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
320 0 CFISH_DECREF(retval);
321 0 sv_2mortal( ST(0) );
322 0 XSRETURN(1);
323 }
324  
325 XS_INTERNAL(XS_Lucy_Test_Analysis_TestAnalyzer_run);
326 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestAnalyzer_run) {
327 0 dXSARGS;
328 SV *sv;
329 testlucy_TestAnalyzer* arg_self;
330 cfish_TestBatchRunner* arg_runner;
331 TESTLUCY_TestAnalyzer_Run_t method;
332  
333 CFISH_UNUSED_VAR(cv);
334 0 SP -= items;
335 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
336 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
337 }
338  
339 /* Extract vars from Perl stack. */
340 0 arg_self = (testlucy_TestAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTANALYZER, NULL);
341 0 sv = ST(1);
342 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
343  
344 /* Execute */
345 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTANALYZER, TESTLUCY_TestAnalyzer_Run);
346 0 method(arg_self, arg_runner);
347 0 XSRETURN(0);
348 }
349  
350 XS_INTERNAL(XS_Lucy_Test_Analysis_TestCaseFolder_run);
351 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestCaseFolder_run) {
352 0 dXSARGS;
353 SV *sv;
354 testlucy_TestCaseFolder* arg_self;
355 cfish_TestBatchRunner* arg_runner;
356 TESTLUCY_TestCaseFolder_Run_t method;
357  
358 CFISH_UNUSED_VAR(cv);
359 0 SP -= items;
360 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
361 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
362 }
363  
364 /* Extract vars from Perl stack. */
365 0 arg_self = (testlucy_TestCaseFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCASEFOLDER, NULL);
366 0 sv = ST(1);
367 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
368  
369 /* Execute */
370 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTCASEFOLDER, TESTLUCY_TestCaseFolder_Run);
371 0 method(arg_self, arg_runner);
372 0 XSRETURN(0);
373 }
374  
375 XS_INTERNAL(XS_Lucy_Test_Analysis_TestNormalizer_run);
376 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestNormalizer_run) {
377 0 dXSARGS;
378 SV *sv;
379 testlucy_TestNormalizer* arg_self;
380 cfish_TestBatchRunner* arg_runner;
381 TESTLUCY_TestNormalizer_Run_t method;
382  
383 CFISH_UNUSED_VAR(cv);
384 0 SP -= items;
385 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
386 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
387 }
388  
389 /* Extract vars from Perl stack. */
390 0 arg_self = (testlucy_TestNormalizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNORMALIZER, NULL);
391 0 sv = ST(1);
392 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
393  
394 /* Execute */
395 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTNORMALIZER, TESTLUCY_TestNormalizer_Run);
396 0 method(arg_self, arg_runner);
397 0 XSRETURN(0);
398 }
399  
400 XS_INTERNAL(XS_Lucy_Test_Analysis_TestPolyAnalyzer_run);
401 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestPolyAnalyzer_run) {
402 0 dXSARGS;
403 SV *sv;
404 testlucy_TestPolyAnalyzer* arg_self;
405 cfish_TestBatchRunner* arg_runner;
406 TESTLUCY_TestPolyAnalyzer_Run_t method;
407  
408 CFISH_UNUSED_VAR(cv);
409 0 SP -= items;
410 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
411 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
412 }
413  
414 /* Extract vars from Perl stack. */
415 0 arg_self = (testlucy_TestPolyAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOLYANALYZER, NULL);
416 0 sv = ST(1);
417 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
418  
419 /* Execute */
420 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPOLYANALYZER, TESTLUCY_TestPolyAnalyzer_Run);
421 0 method(arg_self, arg_runner);
422 0 XSRETURN(0);
423 }
424  
425 XS_INTERNAL(XS_Lucy_Test_Analysis_TestRegexTokenizer_run);
426 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestRegexTokenizer_run) {
427 0 dXSARGS;
428 SV *sv;
429 testlucy_TestRegexTokenizer* arg_self;
430 cfish_TestBatchRunner* arg_runner;
431 TESTLUCY_TestRegexTokenizer_Run_t method;
432  
433 CFISH_UNUSED_VAR(cv);
434 0 SP -= items;
435 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
436 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
437 }
438  
439 /* Extract vars from Perl stack. */
440 0 arg_self = (testlucy_TestRegexTokenizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREGEXTOKENIZER, NULL);
441 0 sv = ST(1);
442 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
443  
444 /* Execute */
445 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTREGEXTOKENIZER, TESTLUCY_TestRegexTokenizer_Run);
446 0 method(arg_self, arg_runner);
447 0 XSRETURN(0);
448 }
449  
450 XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStemmer_run);
451 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStemmer_run) {
452 0 dXSARGS;
453 SV *sv;
454 testlucy_TestSnowballStemmer* arg_self;
455 cfish_TestBatchRunner* arg_runner;
456 TESTLUCY_TestSnowStemmer_Run_t method;
457  
458 CFISH_UNUSED_VAR(cv);
459 0 SP -= items;
460 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
461 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
462 }
463  
464 /* Extract vars from Perl stack. */
465 0 arg_self = (testlucy_TestSnowballStemmer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNOWBALLSTEMMER, NULL);
466 0 sv = ST(1);
467 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
468  
469 /* Execute */
470 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSNOWBALLSTEMMER, TESTLUCY_TestSnowStemmer_Run);
471 0 method(arg_self, arg_runner);
472 0 XSRETURN(0);
473 }
474  
475 XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStopFilter_run);
476 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStopFilter_run) {
477 0 dXSARGS;
478 SV *sv;
479 testlucy_TestSnowballStopFilter* arg_self;
480 cfish_TestBatchRunner* arg_runner;
481 TESTLUCY_TestSnowStop_Run_t method;
482  
483 CFISH_UNUSED_VAR(cv);
484 0 SP -= items;
485 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
486 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
487 }
488  
489 /* Extract vars from Perl stack. */
490 0 arg_self = (testlucy_TestSnowballStopFilter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNOWBALLSTOPFILTER, NULL);
491 0 sv = ST(1);
492 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
493  
494 /* Execute */
495 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSNOWBALLSTOPFILTER, TESTLUCY_TestSnowStop_Run);
496 0 method(arg_self, arg_runner);
497 0 XSRETURN(0);
498 }
499  
500 XS_INTERNAL(XS_Lucy_Test_Analysis_TestStandardTokenizer_run);
501 0 XS_INTERNAL(XS_Lucy_Test_Analysis_TestStandardTokenizer_run) {
502 0 dXSARGS;
503 SV *sv;
504 testlucy_TestStandardTokenizer* arg_self;
505 cfish_TestBatchRunner* arg_runner;
506 TESTLUCY_TestStandardTokenizer_Run_t method;
507  
508 CFISH_UNUSED_VAR(cv);
509 0 SP -= items;
510 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
511 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
512 }
513  
514 /* Extract vars from Perl stack. */
515 0 arg_self = (testlucy_TestStandardTokenizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSTANDARDTOKENIZER, NULL);
516 0 sv = ST(1);
517 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
518  
519 /* Execute */
520 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSTANDARDTOKENIZER, TESTLUCY_TestStandardTokenizer_Run);
521 0 method(arg_self, arg_runner);
522 0 XSRETURN(0);
523 }
524  
525 XS_INTERNAL(XS_Lucy_Test_Highlight_TestHeatMap_run);
526 0 XS_INTERNAL(XS_Lucy_Test_Highlight_TestHeatMap_run) {
527 0 dXSARGS;
528 SV *sv;
529 testlucy_TestHeatMap* arg_self;
530 cfish_TestBatchRunner* arg_runner;
531 TESTLUCY_TestHeatMap_Run_t method;
532  
533 CFISH_UNUSED_VAR(cv);
534 0 SP -= items;
535 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
536 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
537 }
538  
539 /* Extract vars from Perl stack. */
540 0 arg_self = (testlucy_TestHeatMap*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHEATMAP, NULL);
541 0 sv = ST(1);
542 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
543  
544 /* Execute */
545 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTHEATMAP, TESTLUCY_TestHeatMap_Run);
546 0 method(arg_self, arg_runner);
547 0 XSRETURN(0);
548 }
549  
550 XS_INTERNAL(XS_Lucy_Test_Highlight_TestHighlighter_run);
551 0 XS_INTERNAL(XS_Lucy_Test_Highlight_TestHighlighter_run) {
552 0 dXSARGS;
553 SV *sv;
554 testlucy_TestHighlighter* arg_self;
555 cfish_TestBatchRunner* arg_runner;
556 TESTLUCY_TestHighlighter_Run_t method;
557  
558 CFISH_UNUSED_VAR(cv);
559 0 SP -= items;
560 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
561 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
562 }
563  
564 /* Extract vars from Perl stack. */
565 0 arg_self = (testlucy_TestHighlighter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHIGHLIGHTER, NULL);
566 0 sv = ST(1);
567 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
568  
569 /* Execute */
570 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTHIGHLIGHTER, TESTLUCY_TestHighlighter_Run);
571 0 method(arg_self, arg_runner);
572 0 XSRETURN(0);
573 }
574  
575 XS_INTERNAL(XS_Lucy_Test_Index_NoMergeManager_recycle);
576 0 XS_INTERNAL(XS_Lucy_Test_Index_NoMergeManager_recycle) {
577 0 dXSARGS;
578 static const XSBind_ParamSpec param_specs[4] = {
579 XSBIND_PARAM("reader", 1),
580 XSBIND_PARAM("del_writer", 1),
581 XSBIND_PARAM("cutoff", 1),
582 XSBIND_PARAM("optimize", 0)
583 };
584 int32_t locations[4];
585 SV *sv;
586 testlucy_NoMergeManager* arg_self;
587 lucy_PolyReader* arg_reader;
588 lucy_DeletionsWriter* arg_del_writer;
589 int64_t arg_cutoff;
590 bool arg_optimize;
591 TESTLUCY_NoMergeManager_Recycle_t method;
592 cfish_Vector* retval;
593  
594 CFISH_UNUSED_VAR(cv);
595 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
596 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
597 }
598 0 SP -= items;
599  
600 /* Locate args on Perl stack. */
601 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
602 locations, 4);
603 0 arg_self = (testlucy_NoMergeManager*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_NOMERGEMANAGER, NULL);
604 0 sv = ST(locations[0]);
605 0 arg_reader = (lucy_PolyReader*)XSBind_arg_to_cfish(aTHX_ sv, "reader", LUCY_POLYREADER, NULL);
606 0 sv = ST(locations[1]);
607 0 arg_del_writer = (lucy_DeletionsWriter*)XSBind_arg_to_cfish(aTHX_ sv, "del_writer", LUCY_DELETIONSWRITER, NULL);
608 0 sv = ST(locations[2]);
609 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
610 0 XSBind_undef_arg_error(aTHX_ "cutoff");
611 }
612 0 arg_cutoff = (int64_t)SvNV(sv);
613 0 sv = ST(locations[3]);
614 0 ▶ arg_optimize = locations[3] < items && XSBind_sv_defined(aTHX_ sv)
Branch: 2 branches
BranchTrueFalseTotal
arg_optimize = locations[3] < items && XSBind_sv_defined(aTHX_ sv) 0 0 0
arg_optimize = locations[3] < items && XSBind_sv_defined(aTHX_ sv) 0 0 0
615 0 ▶ ? XSBind_sv_true(aTHX_ sv) : false;
Branch: 2 branches
BranchTrueFalseTotal
? XSBind_sv_true(aTHX_ sv) : false; 0 0 0
? XSBind_sv_true(aTHX_ sv) : false; 0 0 0
616  
617 /* Execute */
618 0 method = CFISH_METHOD_PTR(TESTLUCY_NOMERGEMANAGER, TESTLUCY_NoMergeManager_Recycle);
619 0 retval = method(arg_self, arg_reader, arg_del_writer, arg_cutoff, arg_optimize);
620 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
621 0 CFISH_DECREF(retval);
622 0 sv_2mortal( ST(0) );
623 0 XSRETURN(1);
624 }
625  
626 XS_INTERNAL(XS_Lucy_Test_Index_TestBackgroundMerger_run);
627 0 XS_INTERNAL(XS_Lucy_Test_Index_TestBackgroundMerger_run) {
628 0 dXSARGS;
629 SV *sv;
630 testlucy_TestBackgroundMerger* arg_self;
631 cfish_TestBatchRunner* arg_runner;
632 TESTLUCY_TestBGMerger_Run_t method;
633  
634 CFISH_UNUSED_VAR(cv);
635 0 SP -= items;
636 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
637 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
638 }
639  
640 /* Extract vars from Perl stack. */
641 0 arg_self = (testlucy_TestBackgroundMerger*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBACKGROUNDMERGER, NULL);
642 0 sv = ST(1);
643 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
644  
645 /* Execute */
646 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTBACKGROUNDMERGER, TESTLUCY_TestBGMerger_Run);
647 0 method(arg_self, arg_runner);
648 0 XSRETURN(0);
649 }
650  
651 XS_INTERNAL(XS_Lucy_Test_Index_TestDocWriter_run);
652 0 XS_INTERNAL(XS_Lucy_Test_Index_TestDocWriter_run) {
653 0 dXSARGS;
654 SV *sv;
655 testlucy_TestDocWriter* arg_self;
656 cfish_TestBatchRunner* arg_runner;
657 TESTLUCY_TestDocWriter_Run_t method;
658  
659 CFISH_UNUSED_VAR(cv);
660 0 SP -= items;
661 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
662 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
663 }
664  
665 /* Extract vars from Perl stack. */
666 0 arg_self = (testlucy_TestDocWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTDOCWRITER, NULL);
667 0 sv = ST(1);
668 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
669  
670 /* Execute */
671 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTDOCWRITER, TESTLUCY_TestDocWriter_Run);
672 0 method(arg_self, arg_runner);
673 0 XSRETURN(0);
674 }
675  
676 XS_INTERNAL(XS_Lucy_Test_Index_TestHighlightWriter_run);
677 0 XS_INTERNAL(XS_Lucy_Test_Index_TestHighlightWriter_run) {
678 0 dXSARGS;
679 SV *sv;
680 testlucy_TestHighlightWriter* arg_self;
681 cfish_TestBatchRunner* arg_runner;
682 TESTLUCY_TestHLWriter_Run_t method;
683  
684 CFISH_UNUSED_VAR(cv);
685 0 SP -= items;
686 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
687 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
688 }
689  
690 /* Extract vars from Perl stack. */
691 0 arg_self = (testlucy_TestHighlightWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHIGHLIGHTWRITER, NULL);
692 0 sv = ST(1);
693 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
694  
695 /* Execute */
696 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTHIGHLIGHTWRITER, TESTLUCY_TestHLWriter_Run);
697 0 method(arg_self, arg_runner);
698 0 XSRETURN(0);
699 }
700  
701 XS_INTERNAL(XS_Lucy_Test_Index_TestIndexManager_run);
702 0 XS_INTERNAL(XS_Lucy_Test_Index_TestIndexManager_run) {
703 0 dXSARGS;
704 SV *sv;
705 testlucy_TestIndexManager* arg_self;
706 cfish_TestBatchRunner* arg_runner;
707 TESTLUCY_TestIxManager_Run_t method;
708  
709 CFISH_UNUSED_VAR(cv);
710 0 SP -= items;
711 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
712 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
713 }
714  
715 /* Extract vars from Perl stack. */
716 0 arg_self = (testlucy_TestIndexManager*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINDEXMANAGER, NULL);
717 0 sv = ST(1);
718 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
719  
720 /* Execute */
721 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTINDEXMANAGER, TESTLUCY_TestIxManager_Run);
722 0 method(arg_self, arg_runner);
723 0 XSRETURN(0);
724 }
725  
726 XS_INTERNAL(XS_Lucy_Test_Index_TestPolyReader_run);
727 0 XS_INTERNAL(XS_Lucy_Test_Index_TestPolyReader_run) {
728 0 dXSARGS;
729 SV *sv;
730 testlucy_TestPolyReader* arg_self;
731 cfish_TestBatchRunner* arg_runner;
732 TESTLUCY_TestPolyReader_Run_t method;
733  
734 CFISH_UNUSED_VAR(cv);
735 0 SP -= items;
736 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
737 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
738 }
739  
740 /* Extract vars from Perl stack. */
741 0 arg_self = (testlucy_TestPolyReader*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOLYREADER, NULL);
742 0 sv = ST(1);
743 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
744  
745 /* Execute */
746 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPOLYREADER, TESTLUCY_TestPolyReader_Run);
747 0 method(arg_self, arg_runner);
748 0 XSRETURN(0);
749 }
750  
751 XS_INTERNAL(XS_Lucy_Test_Index_TestPostingListWriter_run);
752 0 XS_INTERNAL(XS_Lucy_Test_Index_TestPostingListWriter_run) {
753 0 dXSARGS;
754 SV *sv;
755 testlucy_TestPostingListWriter* arg_self;
756 cfish_TestBatchRunner* arg_runner;
757 TESTLUCY_TestPListWriter_Run_t method;
758  
759 CFISH_UNUSED_VAR(cv);
760 0 SP -= items;
761 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
762 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
763 }
764  
765 /* Extract vars from Perl stack. */
766 0 arg_self = (testlucy_TestPostingListWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOSTINGLISTWRITER, NULL);
767 0 sv = ST(1);
768 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
769  
770 /* Execute */
771 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPOSTINGLISTWRITER, TESTLUCY_TestPListWriter_Run);
772 0 method(arg_self, arg_runner);
773 0 XSRETURN(0);
774 }
775  
776 XS_INTERNAL(XS_Lucy_Test_Index_TestSegWriter_run);
777 0 XS_INTERNAL(XS_Lucy_Test_Index_TestSegWriter_run) {
778 0 dXSARGS;
779 SV *sv;
780 testlucy_TestSegWriter* arg_self;
781 cfish_TestBatchRunner* arg_runner;
782 TESTLUCY_TestSegWriter_Run_t method;
783  
784 CFISH_UNUSED_VAR(cv);
785 0 SP -= items;
786 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
787 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
788 }
789  
790 /* Extract vars from Perl stack. */
791 0 arg_self = (testlucy_TestSegWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSEGWRITER, NULL);
792 0 sv = ST(1);
793 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
794  
795 /* Execute */
796 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSEGWRITER, TESTLUCY_TestSegWriter_Run);
797 0 method(arg_self, arg_runner);
798 0 XSRETURN(0);
799 }
800  
801 XS_INTERNAL(XS_Lucy_Test_Index_TestSegment_run);
802 0 XS_INTERNAL(XS_Lucy_Test_Index_TestSegment_run) {
803 0 dXSARGS;
804 SV *sv;
805 testlucy_TestSegment* arg_self;
806 cfish_TestBatchRunner* arg_runner;
807 TESTLUCY_TestSeg_Run_t method;
808  
809 CFISH_UNUSED_VAR(cv);
810 0 SP -= items;
811 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
812 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
813 }
814  
815 /* Extract vars from Perl stack. */
816 0 arg_self = (testlucy_TestSegment*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSEGMENT, NULL);
817 0 sv = ST(1);
818 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
819  
820 /* Execute */
821 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSEGMENT, TESTLUCY_TestSeg_Run);
822 0 method(arg_self, arg_runner);
823 0 XSRETURN(0);
824 }
825  
826 XS_INTERNAL(XS_Lucy_Test_Index_TestSnapshot_run);
827 0 XS_INTERNAL(XS_Lucy_Test_Index_TestSnapshot_run) {
828 0 dXSARGS;
829 SV *sv;
830 testlucy_TestSnapshot* arg_self;
831 cfish_TestBatchRunner* arg_runner;
832 TESTLUCY_TestSnapshot_Run_t method;
833  
834 CFISH_UNUSED_VAR(cv);
835 0 SP -= items;
836 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
837 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
838 }
839  
840 /* Extract vars from Perl stack. */
841 0 arg_self = (testlucy_TestSnapshot*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNAPSHOT, NULL);
842 0 sv = ST(1);
843 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
844  
845 /* Execute */
846 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSNAPSHOT, TESTLUCY_TestSnapshot_Run);
847 0 method(arg_self, arg_runner);
848 0 XSRETURN(0);
849 }
850  
851 XS_INTERNAL(XS_Lucy_Test_Index_TestSortWriter_run);
852 0 XS_INTERNAL(XS_Lucy_Test_Index_TestSortWriter_run) {
853 0 dXSARGS;
854 SV *sv;
855 testlucy_TestSortWriter* arg_self;
856 cfish_TestBatchRunner* arg_runner;
857 TESTLUCY_TestSortWriter_Run_t method;
858  
859 CFISH_UNUSED_VAR(cv);
860 0 SP -= items;
861 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
862 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
863 }
864  
865 /* Extract vars from Perl stack. */
866 0 arg_self = (testlucy_TestSortWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTWRITER, NULL);
867 0 sv = ST(1);
868 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
869  
870 /* Execute */
871 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTWRITER, TESTLUCY_TestSortWriter_Run);
872 0 method(arg_self, arg_runner);
873 0 XSRETURN(0);
874 }
875  
876 XS_INTERNAL(XS_Lucy_Test_Index_TestTermInfo_run);
877 0 XS_INTERNAL(XS_Lucy_Test_Index_TestTermInfo_run) {
878 0 dXSARGS;
879 SV *sv;
880 testlucy_TestTermInfo* arg_self;
881 cfish_TestBatchRunner* arg_runner;
882 TESTLUCY_TestTermInfo_Run_t method;
883  
884 CFISH_UNUSED_VAR(cv);
885 0 SP -= items;
886 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
887 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
888 }
889  
890 /* Extract vars from Perl stack. */
891 0 arg_self = (testlucy_TestTermInfo*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTTERMINFO, NULL);
892 0 sv = ST(1);
893 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
894  
895 /* Execute */
896 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTTERMINFO, TESTLUCY_TestTermInfo_Run);
897 0 method(arg_self, arg_runner);
898 0 XSRETURN(0);
899 }
900  
901 XS_INTERNAL(XS_Lucy_Test_Object_TestBitVector_run);
902 0 XS_INTERNAL(XS_Lucy_Test_Object_TestBitVector_run) {
903 0 dXSARGS;
904 SV *sv;
905 testlucy_TestBitVector* arg_self;
906 cfish_TestBatchRunner* arg_runner;
907 TESTLUCY_TestBitVector_Run_t method;
908  
909 CFISH_UNUSED_VAR(cv);
910 0 SP -= items;
911 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
912 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
913 }
914  
915 /* Extract vars from Perl stack. */
916 0 arg_self = (testlucy_TestBitVector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBITVECTOR, NULL);
917 0 sv = ST(1);
918 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
919  
920 /* Execute */
921 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTBITVECTOR, TESTLUCY_TestBitVector_Run);
922 0 method(arg_self, arg_runner);
923 0 XSRETURN(0);
924 }
925  
926 XS_INTERNAL(XS_Lucy_Test_Object_TestI32Array_run);
927 0 XS_INTERNAL(XS_Lucy_Test_Object_TestI32Array_run) {
928 0 dXSARGS;
929 SV *sv;
930 testlucy_TestI32Array* arg_self;
931 cfish_TestBatchRunner* arg_runner;
932 TESTLUCY_TestI32Arr_Run_t method;
933  
934 CFISH_UNUSED_VAR(cv);
935 0 SP -= items;
936 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
937 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
938 }
939  
940 /* Extract vars from Perl stack. */
941 0 arg_self = (testlucy_TestI32Array*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTI32ARRAY, NULL);
942 0 sv = ST(1);
943 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
944  
945 /* Execute */
946 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTI32ARRAY, TESTLUCY_TestI32Arr_Run);
947 0 method(arg_self, arg_runner);
948 0 XSRETURN(0);
949 }
950  
951 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_new);
952 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_new) {
953 0 dXSARGS;
954 testlucy_TestArchitecture* arg_self;
955 testlucy_TestArchitecture* retval;
956  
957 CFISH_UNUSED_VAR(cv);
958 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
959 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
960 }
961 0 SP -= items;
962  
963 0 arg_self = (testlucy_TestArchitecture*)XSBind_new_blank_obj(aTHX_ ST(0));
964  
965 0 retval = testlucy_TestArch_init(arg_self);
966 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
967 0 XSRETURN(1);
968 }
969  
970  
971 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_index_interval);
972 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_index_interval) {
973 0 dXSARGS;
974 testlucy_TestArchitecture* arg_self;
975 TESTLUCY_TestArch_Index_Interval_t method;
976 int32_t retval;
977  
978 CFISH_UNUSED_VAR(cv);
979 0 SP -= items;
980 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
981 0 XSBind_invalid_args_error(aTHX_ cv, "self");
982 }
983  
984 /* Extract vars from Perl stack. */
985 0 arg_self = (testlucy_TestArchitecture*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTARCHITECTURE, NULL);
986  
987 /* Execute */
988 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTARCHITECTURE, TESTLUCY_TestArch_Index_Interval);
989 0 retval = method(arg_self);
990 0 ST(0) = newSViv(retval);
991 0 sv_2mortal( ST(0) );
992 0 XSRETURN(1);
993 }
994  
995 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_skip_interval);
996 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_skip_interval) {
997 0 dXSARGS;
998 testlucy_TestArchitecture* arg_self;
999 TESTLUCY_TestArch_Skip_Interval_t method;
1000 int32_t retval;
1001  
1002 CFISH_UNUSED_VAR(cv);
1003 0 SP -= items;
1004 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1005 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1006 }
1007  
1008 /* Extract vars from Perl stack. */
1009 0 arg_self = (testlucy_TestArchitecture*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTARCHITECTURE, NULL);
1010  
1011 /* Execute */
1012 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTARCHITECTURE, TESTLUCY_TestArch_Skip_Interval);
1013 0 retval = method(arg_self);
1014 0 ST(0) = newSViv(retval);
1015 0 sv_2mortal( ST(0) );
1016 0 XSRETURN(1);
1017 }
1018  
1019 XS_INTERNAL(XS_Lucy_Test_Plan_TestBlobType_run);
1020 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestBlobType_run) {
1021 0 dXSARGS;
1022 SV *sv;
1023 testlucy_TestBlobType* arg_self;
1024 cfish_TestBatchRunner* arg_runner;
1025 TESTLUCY_TestBlobType_Run_t method;
1026  
1027 CFISH_UNUSED_VAR(cv);
1028 0 SP -= items;
1029 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1030 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1031 }
1032  
1033 /* Extract vars from Perl stack. */
1034 0 arg_self = (testlucy_TestBlobType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBLOBTYPE, NULL);
1035 0 sv = ST(1);
1036 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1037  
1038 /* Execute */
1039 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTBLOBTYPE, TESTLUCY_TestBlobType_Run);
1040 0 method(arg_self, arg_runner);
1041 0 XSRETURN(0);
1042 }
1043  
1044 XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldMisc_run);
1045 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldMisc_run) {
1046 0 dXSARGS;
1047 SV *sv;
1048 testlucy_TestFieldMisc* arg_self;
1049 cfish_TestBatchRunner* arg_runner;
1050 TESTLUCY_TestFieldMisc_Run_t method;
1051  
1052 CFISH_UNUSED_VAR(cv);
1053 0 SP -= items;
1054 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1055 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1056 }
1057  
1058 /* Extract vars from Perl stack. */
1059 0 arg_self = (testlucy_TestFieldMisc*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFIELDMISC, NULL);
1060 0 sv = ST(1);
1061 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1062  
1063 /* Execute */
1064 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFIELDMISC, TESTLUCY_TestFieldMisc_Run);
1065 0 method(arg_self, arg_runner);
1066 0 XSRETURN(0);
1067 }
1068  
1069 XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldType_run);
1070 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldType_run) {
1071 0 dXSARGS;
1072 SV *sv;
1073 testlucy_TestFieldType* arg_self;
1074 cfish_TestBatchRunner* arg_runner;
1075 TESTLUCY_TestFType_Run_t method;
1076  
1077 CFISH_UNUSED_VAR(cv);
1078 0 SP -= items;
1079 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1080 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1081 }
1082  
1083 /* Extract vars from Perl stack. */
1084 0 arg_self = (testlucy_TestFieldType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFIELDTYPE, NULL);
1085 0 sv = ST(1);
1086 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1087  
1088 /* Execute */
1089 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFIELDTYPE, TESTLUCY_TestFType_Run);
1090 0 method(arg_self, arg_runner);
1091 0 XSRETURN(0);
1092 }
1093  
1094 XS_INTERNAL(XS_Lucy_Test_Plan_TestFullTextType_run);
1095 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestFullTextType_run) {
1096 0 dXSARGS;
1097 SV *sv;
1098 testlucy_TestFullTextType* arg_self;
1099 cfish_TestBatchRunner* arg_runner;
1100 TESTLUCY_TestFullTextType_Run_t method;
1101  
1102 CFISH_UNUSED_VAR(cv);
1103 0 SP -= items;
1104 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1105 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1106 }
1107  
1108 /* Extract vars from Perl stack. */
1109 0 arg_self = (testlucy_TestFullTextType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFULLTEXTTYPE, NULL);
1110 0 sv = ST(1);
1111 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1112  
1113 /* Execute */
1114 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFULLTEXTTYPE, TESTLUCY_TestFullTextType_Run);
1115 0 method(arg_self, arg_runner);
1116 0 XSRETURN(0);
1117 }
1118  
1119 XS_INTERNAL(XS_Lucy_Test_Plan_TestNumericType_run);
1120 0 XS_INTERNAL(XS_Lucy_Test_Plan_TestNumericType_run) {
1121 0 dXSARGS;
1122 SV *sv;
1123 testlucy_TestNumericType* arg_self;
1124 cfish_TestBatchRunner* arg_runner;
1125 TESTLUCY_TestNumericType_Run_t method;
1126  
1127 CFISH_UNUSED_VAR(cv);
1128 0 SP -= items;
1129 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1130 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1131 }
1132  
1133 /* Extract vars from Perl stack. */
1134 0 arg_self = (testlucy_TestNumericType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNUMERICTYPE, NULL);
1135 0 sv = ST(1);
1136 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1137  
1138 /* Execute */
1139 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTNUMERICTYPE, TESTLUCY_TestNumericType_Run);
1140 0 method(arg_self, arg_runner);
1141 0 XSRETURN(0);
1142 }
1143  
1144 XS_INTERNAL(XS_Lucy_Test_Search_TestANDQuery_run);
1145 0 XS_INTERNAL(XS_Lucy_Test_Search_TestANDQuery_run) {
1146 0 dXSARGS;
1147 SV *sv;
1148 testlucy_TestANDQuery* arg_self;
1149 cfish_TestBatchRunner* arg_runner;
1150 TESTLUCY_TestANDQuery_Run_t method;
1151  
1152 CFISH_UNUSED_VAR(cv);
1153 0 SP -= items;
1154 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1155 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1156 }
1157  
1158 /* Extract vars from Perl stack. */
1159 0 arg_self = (testlucy_TestANDQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTANDQUERY, NULL);
1160 0 sv = ST(1);
1161 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1162  
1163 /* Execute */
1164 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTANDQUERY, TESTLUCY_TestANDQuery_Run);
1165 0 method(arg_self, arg_runner);
1166 0 XSRETURN(0);
1167 }
1168  
1169 XS_INTERNAL(XS_Lucy_Test_Search_TestLeafQuery_run);
1170 0 XS_INTERNAL(XS_Lucy_Test_Search_TestLeafQuery_run) {
1171 0 dXSARGS;
1172 SV *sv;
1173 testlucy_TestLeafQuery* arg_self;
1174 cfish_TestBatchRunner* arg_runner;
1175 TESTLUCY_TestLeafQuery_Run_t method;
1176  
1177 CFISH_UNUSED_VAR(cv);
1178 0 SP -= items;
1179 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1180 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1181 }
1182  
1183 /* Extract vars from Perl stack. */
1184 0 arg_self = (testlucy_TestLeafQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTLEAFQUERY, NULL);
1185 0 sv = ST(1);
1186 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1187  
1188 /* Execute */
1189 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTLEAFQUERY, TESTLUCY_TestLeafQuery_Run);
1190 0 method(arg_self, arg_runner);
1191 0 XSRETURN(0);
1192 }
1193  
1194 XS_INTERNAL(XS_Lucy_Test_Search_TestMatchAllQuery_run);
1195 0 XS_INTERNAL(XS_Lucy_Test_Search_TestMatchAllQuery_run) {
1196 0 dXSARGS;
1197 SV *sv;
1198 testlucy_TestMatchAllQuery* arg_self;
1199 cfish_TestBatchRunner* arg_runner;
1200 TESTLUCY_TestMatchAllQuery_Run_t method;
1201  
1202 CFISH_UNUSED_VAR(cv);
1203 0 SP -= items;
1204 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1205 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1206 }
1207  
1208 /* Extract vars from Perl stack. */
1209 0 arg_self = (testlucy_TestMatchAllQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTMATCHALLQUERY, NULL);
1210 0 sv = ST(1);
1211 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1212  
1213 /* Execute */
1214 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTMATCHALLQUERY, TESTLUCY_TestMatchAllQuery_Run);
1215 0 method(arg_self, arg_runner);
1216 0 XSRETURN(0);
1217 }
1218  
1219 XS_INTERNAL(XS_Lucy_Test_Search_TestNOTQuery_run);
1220 0 XS_INTERNAL(XS_Lucy_Test_Search_TestNOTQuery_run) {
1221 0 dXSARGS;
1222 SV *sv;
1223 testlucy_TestNOTQuery* arg_self;
1224 cfish_TestBatchRunner* arg_runner;
1225 TESTLUCY_TestNOTQuery_Run_t method;
1226  
1227 CFISH_UNUSED_VAR(cv);
1228 0 SP -= items;
1229 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1230 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1231 }
1232  
1233 /* Extract vars from Perl stack. */
1234 0 arg_self = (testlucy_TestNOTQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNOTQUERY, NULL);
1235 0 sv = ST(1);
1236 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1237  
1238 /* Execute */
1239 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTNOTQUERY, TESTLUCY_TestNOTQuery_Run);
1240 0 method(arg_self, arg_runner);
1241 0 XSRETURN(0);
1242 }
1243  
1244 XS_INTERNAL(XS_Lucy_Test_Search_TestNoMatchQuery_run);
1245 0 XS_INTERNAL(XS_Lucy_Test_Search_TestNoMatchQuery_run) {
1246 0 dXSARGS;
1247 SV *sv;
1248 testlucy_TestNoMatchQuery* arg_self;
1249 cfish_TestBatchRunner* arg_runner;
1250 TESTLUCY_TestNoMatchQuery_Run_t method;
1251  
1252 CFISH_UNUSED_VAR(cv);
1253 0 SP -= items;
1254 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1255 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1256 }
1257  
1258 /* Extract vars from Perl stack. */
1259 0 arg_self = (testlucy_TestNoMatchQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNOMATCHQUERY, NULL);
1260 0 sv = ST(1);
1261 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1262  
1263 /* Execute */
1264 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTNOMATCHQUERY, TESTLUCY_TestNoMatchQuery_Run);
1265 0 method(arg_self, arg_runner);
1266 0 XSRETURN(0);
1267 }
1268  
1269 XS_INTERNAL(XS_Lucy_Test_Search_TestORQuery_run);
1270 0 XS_INTERNAL(XS_Lucy_Test_Search_TestORQuery_run) {
1271 0 dXSARGS;
1272 SV *sv;
1273 testlucy_TestORQuery* arg_self;
1274 cfish_TestBatchRunner* arg_runner;
1275 TESTLUCY_TestORQuery_Run_t method;
1276  
1277 CFISH_UNUSED_VAR(cv);
1278 0 SP -= items;
1279 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1280 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1281 }
1282  
1283 /* Extract vars from Perl stack. */
1284 0 arg_self = (testlucy_TestORQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTORQUERY, NULL);
1285 0 sv = ST(1);
1286 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1287  
1288 /* Execute */
1289 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTORQUERY, TESTLUCY_TestORQuery_Run);
1290 0 method(arg_self, arg_runner);
1291 0 XSRETURN(0);
1292 }
1293  
1294 XS_INTERNAL(XS_Lucy_Test_Search_TestPhraseQuery_run);
1295 0 XS_INTERNAL(XS_Lucy_Test_Search_TestPhraseQuery_run) {
1296 0 dXSARGS;
1297 SV *sv;
1298 testlucy_TestPhraseQuery* arg_self;
1299 cfish_TestBatchRunner* arg_runner;
1300 TESTLUCY_TestPhraseQuery_Run_t method;
1301  
1302 CFISH_UNUSED_VAR(cv);
1303 0 SP -= items;
1304 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1305 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1306 }
1307  
1308 /* Extract vars from Perl stack. */
1309 0 arg_self = (testlucy_TestPhraseQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPHRASEQUERY, NULL);
1310 0 sv = ST(1);
1311 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1312  
1313 /* Execute */
1314 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPHRASEQUERY, TESTLUCY_TestPhraseQuery_Run);
1315 0 method(arg_self, arg_runner);
1316 0 XSRETURN(0);
1317 }
1318  
1319 XS_INTERNAL(XS_Lucy_Test_Search_TestPolySearcher_run);
1320 0 XS_INTERNAL(XS_Lucy_Test_Search_TestPolySearcher_run) {
1321 0 dXSARGS;
1322 SV *sv;
1323 testlucy_TestPolySearcher* arg_self;
1324 cfish_TestBatchRunner* arg_runner;
1325 TESTLUCY_TestPolySearcher_Run_t method;
1326  
1327 CFISH_UNUSED_VAR(cv);
1328 0 SP -= items;
1329 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1330 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1331 }
1332  
1333 /* Extract vars from Perl stack. */
1334 0 arg_self = (testlucy_TestPolySearcher*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOLYSEARCHER, NULL);
1335 0 sv = ST(1);
1336 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1337  
1338 /* Execute */
1339 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPOLYSEARCHER, TESTLUCY_TestPolySearcher_Run);
1340 0 method(arg_self, arg_runner);
1341 0 XSRETURN(0);
1342 }
1343  
1344 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_query_string);
1345 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_query_string) {
1346 0 dXSARGS;
1347 testlucy_TestQueryParser* arg_self;
1348 TESTLUCY_TestQP_Get_Query_String_t method;
1349 cfish_String* retval;
1350  
1351 CFISH_UNUSED_VAR(cv);
1352 0 SP -= items;
1353 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1354 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1355 }
1356  
1357 /* Extract vars from Perl stack. */
1358 0 arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);
1359  
1360 /* Execute */
1361 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Query_String);
1362 0 retval = method(arg_self);
1363 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1364 0 sv_2mortal( ST(0) );
1365 0 XSRETURN(1);
1366 }
1367  
1368 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_tree);
1369 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_tree) {
1370 0 dXSARGS;
1371 testlucy_TestQueryParser* arg_self;
1372 TESTLUCY_TestQP_Get_Tree_t method;
1373 lucy_Query* retval;
1374  
1375 CFISH_UNUSED_VAR(cv);
1376 0 SP -= items;
1377 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1378 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1379 }
1380  
1381 /* Extract vars from Perl stack. */
1382 0 arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);
1383  
1384 /* Execute */
1385 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Tree);
1386 0 retval = method(arg_self);
1387 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1388 0 sv_2mortal( ST(0) );
1389 0 XSRETURN(1);
1390 }
1391  
1392 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_expanded);
1393 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_expanded) {
1394 0 dXSARGS;
1395 testlucy_TestQueryParser* arg_self;
1396 TESTLUCY_TestQP_Get_Expanded_t method;
1397 lucy_Query* retval;
1398  
1399 CFISH_UNUSED_VAR(cv);
1400 0 SP -= items;
1401 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1402 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1403 }
1404  
1405 /* Extract vars from Perl stack. */
1406 0 arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);
1407  
1408 /* Execute */
1409 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Expanded);
1410 0 retval = method(arg_self);
1411 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1412 0 sv_2mortal( ST(0) );
1413 0 XSRETURN(1);
1414 }
1415  
1416 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_num_hits);
1417 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_num_hits) {
1418 0 dXSARGS;
1419 testlucy_TestQueryParser* arg_self;
1420 TESTLUCY_TestQP_Get_Num_Hits_t method;
1421 uint32_t retval;
1422  
1423 CFISH_UNUSED_VAR(cv);
1424 0 SP -= items;
1425 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1426 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1427 }
1428  
1429 /* Extract vars from Perl stack. */
1430 0 arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);
1431  
1432 /* Execute */
1433 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Num_Hits);
1434 0 retval = method(arg_self);
1435 0 ST(0) = newSVuv(retval);
1436 0 sv_2mortal( ST(0) );
1437 0 XSRETURN(1);
1438 }
1439  
1440 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserLogic_run);
1441 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserLogic_run) {
1442 0 dXSARGS;
1443 SV *sv;
1444 testlucy_TestQueryParserLogic* arg_self;
1445 cfish_TestBatchRunner* arg_runner;
1446 TESTLUCY_TestQPLogic_Run_t method;
1447  
1448 CFISH_UNUSED_VAR(cv);
1449 0 SP -= items;
1450 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1451 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1452 }
1453  
1454 /* Extract vars from Perl stack. */
1455 0 arg_self = (testlucy_TestQueryParserLogic*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSERLOGIC, NULL);
1456 0 sv = ST(1);
1457 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1458  
1459 /* Execute */
1460 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSERLOGIC, TESTLUCY_TestQPLogic_Run);
1461 0 method(arg_self, arg_runner);
1462 0 XSRETURN(0);
1463 }
1464  
1465 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserSyntax_run);
1466 0 XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserSyntax_run) {
1467 0 dXSARGS;
1468 SV *sv;
1469 testlucy_TestQueryParserSyntax* arg_self;
1470 cfish_TestBatchRunner* arg_runner;
1471 TESTLUCY_TestQPSyntax_Run_t method;
1472  
1473 CFISH_UNUSED_VAR(cv);
1474 0 SP -= items;
1475 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1476 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1477 }
1478  
1479 /* Extract vars from Perl stack. */
1480 0 arg_self = (testlucy_TestQueryParserSyntax*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSERSYNTAX, NULL);
1481 0 sv = ST(1);
1482 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1483  
1484 /* Execute */
1485 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSERSYNTAX, TESTLUCY_TestQPSyntax_Run);
1486 0 method(arg_self, arg_runner);
1487 0 XSRETURN(0);
1488 }
1489  
1490 XS_INTERNAL(XS_Lucy_Test_Search_TestRangeQuery_run);
1491 0 XS_INTERNAL(XS_Lucy_Test_Search_TestRangeQuery_run) {
1492 0 dXSARGS;
1493 SV *sv;
1494 testlucy_TestRangeQuery* arg_self;
1495 cfish_TestBatchRunner* arg_runner;
1496 TESTLUCY_TestRangeQuery_Run_t method;
1497  
1498 CFISH_UNUSED_VAR(cv);
1499 0 SP -= items;
1500 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1501 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1502 }
1503  
1504 /* Extract vars from Perl stack. */
1505 0 arg_self = (testlucy_TestRangeQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRANGEQUERY, NULL);
1506 0 sv = ST(1);
1507 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1508  
1509 /* Execute */
1510 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTRANGEQUERY, TESTLUCY_TestRangeQuery_Run);
1511 0 method(arg_self, arg_runner);
1512 0 XSRETURN(0);
1513 }
1514  
1515 XS_INTERNAL(XS_Lucy_Test_Search_TestReqOptQuery_run);
1516 0 XS_INTERNAL(XS_Lucy_Test_Search_TestReqOptQuery_run) {
1517 0 dXSARGS;
1518 SV *sv;
1519 testlucy_TestReqOptQuery* arg_self;
1520 cfish_TestBatchRunner* arg_runner;
1521 TESTLUCY_TestReqOptQuery_Run_t method;
1522  
1523 CFISH_UNUSED_VAR(cv);
1524 0 SP -= items;
1525 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1526 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1527 }
1528  
1529 /* Extract vars from Perl stack. */
1530 0 arg_self = (testlucy_TestReqOptQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREQOPTQUERY, NULL);
1531 0 sv = ST(1);
1532 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1533  
1534 /* Execute */
1535 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTREQOPTQUERY, TESTLUCY_TestReqOptQuery_Run);
1536 0 method(arg_self, arg_runner);
1537 0 XSRETURN(0);
1538 }
1539  
1540 XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_new);
1541 0 XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_new) {
1542 0 dXSARGS;
1543 testlucy_TestReverseType* arg_self;
1544 testlucy_TestReverseType* retval;
1545  
1546 CFISH_UNUSED_VAR(cv);
1547 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1548 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
1549 }
1550 0 SP -= items;
1551  
1552 0 arg_self = (testlucy_TestReverseType*)XSBind_new_blank_obj(aTHX_ ST(0));
1553  
1554 0 retval = testlucy_TestReverseType_init(arg_self);
1555 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
1556 0 XSRETURN(1);
1557 }
1558  
1559  
1560 XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_compare_values);
1561 0 XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_compare_values) {
1562 0 dXSARGS;
1563 static const XSBind_ParamSpec param_specs[2] = {
1564 XSBIND_PARAM("a", 1),
1565 XSBIND_PARAM("b", 1)
1566 };
1567 int32_t locations[2];
1568 SV *sv;
1569 testlucy_TestReverseType* arg_self;
1570 cfish_Obj* arg_a;
1571 cfish_Obj* arg_b;
1572 TESTLUCY_TestReverseType_Compare_Values_t method;
1573 int32_t retval;
1574  
1575 CFISH_UNUSED_VAR(cv);
1576 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
1577 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
1578 }
1579 0 SP -= items;
1580  
1581 /* Locate args on Perl stack. */
1582 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
1583 locations, 2);
1584 0 arg_self = (testlucy_TestReverseType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREVERSETYPE, NULL);
1585 0 sv = ST(locations[0]);
1586 0 arg_a = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "a", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1587 0 sv = ST(locations[1]);
1588 0 arg_b = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "b", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1589  
1590 /* Execute */
1591 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTREVERSETYPE, TESTLUCY_TestReverseType_Compare_Values);
1592 0 retval = method(arg_self, arg_a, arg_b);
1593 0 ST(0) = newSViv(retval);
1594 0 sv_2mortal( ST(0) );
1595 0 XSRETURN(1);
1596 }
1597  
1598 XS_INTERNAL(XS_Lucy_Test_Search_TestSeriesMatcher_run);
1599 0 XS_INTERNAL(XS_Lucy_Test_Search_TestSeriesMatcher_run) {
1600 0 dXSARGS;
1601 SV *sv;
1602 testlucy_TestSeriesMatcher* arg_self;
1603 cfish_TestBatchRunner* arg_runner;
1604 TESTLUCY_TestSeriesMatcher_Run_t method;
1605  
1606 CFISH_UNUSED_VAR(cv);
1607 0 SP -= items;
1608 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1609 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1610 }
1611  
1612 /* Extract vars from Perl stack. */
1613 0 arg_self = (testlucy_TestSeriesMatcher*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSERIESMATCHER, NULL);
1614 0 sv = ST(1);
1615 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1616  
1617 /* Execute */
1618 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSERIESMATCHER, TESTLUCY_TestSeriesMatcher_Run);
1619 0 method(arg_self, arg_runner);
1620 0 XSRETURN(0);
1621 }
1622  
1623 XS_INTERNAL(XS_Lucy_Test_Search_TestSortSpec_run);
1624 0 XS_INTERNAL(XS_Lucy_Test_Search_TestSortSpec_run) {
1625 0 dXSARGS;
1626 SV *sv;
1627 testlucy_TestSortSpec* arg_self;
1628 cfish_TestBatchRunner* arg_runner;
1629 TESTLUCY_TestSortSpec_Run_t method;
1630  
1631 CFISH_UNUSED_VAR(cv);
1632 0 SP -= items;
1633 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1634 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1635 }
1636  
1637 /* Extract vars from Perl stack. */
1638 0 arg_self = (testlucy_TestSortSpec*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTSPEC, NULL);
1639 0 sv = ST(1);
1640 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1641  
1642 /* Execute */
1643 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTSPEC, TESTLUCY_TestSortSpec_Run);
1644 0 method(arg_self, arg_runner);
1645 0 XSRETURN(0);
1646 }
1647  
1648 XS_INTERNAL(XS_Lucy_Test_Search_TestSpan_run);
1649 0 XS_INTERNAL(XS_Lucy_Test_Search_TestSpan_run) {
1650 0 dXSARGS;
1651 SV *sv;
1652 testlucy_TestSpan* arg_self;
1653 cfish_TestBatchRunner* arg_runner;
1654 TESTLUCY_TestSpan_Run_t method;
1655  
1656 CFISH_UNUSED_VAR(cv);
1657 0 SP -= items;
1658 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1659 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1660 }
1661  
1662 /* Extract vars from Perl stack. */
1663 0 arg_self = (testlucy_TestSpan*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSPAN, NULL);
1664 0 sv = ST(1);
1665 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1666  
1667 /* Execute */
1668 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSPAN, TESTLUCY_TestSpan_Run);
1669 0 method(arg_self, arg_runner);
1670 0 XSRETURN(0);
1671 }
1672  
1673 XS_INTERNAL(XS_Lucy_Test_Search_TestTermQuery_run);
1674 0 XS_INTERNAL(XS_Lucy_Test_Search_TestTermQuery_run) {
1675 0 dXSARGS;
1676 SV *sv;
1677 testlucy_TestTermQuery* arg_self;
1678 cfish_TestBatchRunner* arg_runner;
1679 TESTLUCY_TestTermQuery_Run_t method;
1680  
1681 CFISH_UNUSED_VAR(cv);
1682 0 SP -= items;
1683 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1684 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1685 }
1686  
1687 /* Extract vars from Perl stack. */
1688 0 arg_self = (testlucy_TestTermQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTTERMQUERY, NULL);
1689 0 sv = ST(1);
1690 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1691  
1692 /* Execute */
1693 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTTERMQUERY, TESTLUCY_TestTermQuery_Run);
1694 0 method(arg_self, arg_runner);
1695 0 XSRETURN(0);
1696 }
1697  
1698 XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileReader_run);
1699 0 XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileReader_run) {
1700 0 dXSARGS;
1701 SV *sv;
1702 testlucy_TestCompoundFileReader* arg_self;
1703 cfish_TestBatchRunner* arg_runner;
1704 TESTLUCY_TestCFReader_Run_t method;
1705  
1706 CFISH_UNUSED_VAR(cv);
1707 0 SP -= items;
1708 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1709 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1710 }
1711  
1712 /* Extract vars from Perl stack. */
1713 0 arg_self = (testlucy_TestCompoundFileReader*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCOMPOUNDFILEREADER, NULL);
1714 0 sv = ST(1);
1715 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1716  
1717 /* Execute */
1718 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTCOMPOUNDFILEREADER, TESTLUCY_TestCFReader_Run);
1719 0 method(arg_self, arg_runner);
1720 0 XSRETURN(0);
1721 }
1722  
1723 XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileWriter_run);
1724 0 XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileWriter_run) {
1725 0 dXSARGS;
1726 SV *sv;
1727 testlucy_TestCompoundFileWriter* arg_self;
1728 cfish_TestBatchRunner* arg_runner;
1729 TESTLUCY_TestCFWriter_Run_t method;
1730  
1731 CFISH_UNUSED_VAR(cv);
1732 0 SP -= items;
1733 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1734 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1735 }
1736  
1737 /* Extract vars from Perl stack. */
1738 0 arg_self = (testlucy_TestCompoundFileWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCOMPOUNDFILEWRITER, NULL);
1739 0 sv = ST(1);
1740 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1741  
1742 /* Execute */
1743 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTCOMPOUNDFILEWRITER, TESTLUCY_TestCFWriter_Run);
1744 0 method(arg_self, arg_runner);
1745 0 XSRETURN(0);
1746 }
1747  
1748 XS_INTERNAL(XS_Lucy_Test_Store_TestFSDirHandle_run);
1749 0 XS_INTERNAL(XS_Lucy_Test_Store_TestFSDirHandle_run) {
1750 0 dXSARGS;
1751 SV *sv;
1752 testlucy_TestFSDirHandle* arg_self;
1753 cfish_TestBatchRunner* arg_runner;
1754 TESTLUCY_TestFSDH_Run_t method;
1755  
1756 CFISH_UNUSED_VAR(cv);
1757 0 SP -= items;
1758 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1759 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1760 }
1761  
1762 /* Extract vars from Perl stack. */
1763 0 arg_self = (testlucy_TestFSDirHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSDIRHANDLE, NULL);
1764 0 sv = ST(1);
1765 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1766  
1767 /* Execute */
1768 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFSDIRHANDLE, TESTLUCY_TestFSDH_Run);
1769 0 method(arg_self, arg_runner);
1770 0 XSRETURN(0);
1771 }
1772  
1773 XS_INTERNAL(XS_Lucy_Test_Store_TestFSFileHandle_run);
1774 0 XS_INTERNAL(XS_Lucy_Test_Store_TestFSFileHandle_run) {
1775 0 dXSARGS;
1776 SV *sv;
1777 testlucy_TestFSFileHandle* arg_self;
1778 cfish_TestBatchRunner* arg_runner;
1779 TESTLUCY_TestFSFH_Run_t method;
1780  
1781 CFISH_UNUSED_VAR(cv);
1782 0 SP -= items;
1783 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1784 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1785 }
1786  
1787 /* Extract vars from Perl stack. */
1788 0 arg_self = (testlucy_TestFSFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSFILEHANDLE, NULL);
1789 0 sv = ST(1);
1790 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1791  
1792 /* Execute */
1793 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFSFILEHANDLE, TESTLUCY_TestFSFH_Run);
1794 0 method(arg_self, arg_runner);
1795 0 XSRETURN(0);
1796 }
1797  
1798 XS_INTERNAL(XS_Lucy_Test_Store_TestFSFolder_run);
1799 0 XS_INTERNAL(XS_Lucy_Test_Store_TestFSFolder_run) {
1800 0 dXSARGS;
1801 SV *sv;
1802 testlucy_TestFSFolder* arg_self;
1803 cfish_TestBatchRunner* arg_runner;
1804 TESTLUCY_TestFSFolder_Run_t method;
1805  
1806 CFISH_UNUSED_VAR(cv);
1807 0 SP -= items;
1808 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1809 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1810 }
1811  
1812 /* Extract vars from Perl stack. */
1813 0 arg_self = (testlucy_TestFSFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSFOLDER, NULL);
1814 0 sv = ST(1);
1815 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1816  
1817 /* Execute */
1818 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFSFOLDER, TESTLUCY_TestFSFolder_Run);
1819 0 method(arg_self, arg_runner);
1820 0 XSRETURN(0);
1821 }
1822  
1823 XS_INTERNAL(XS_Lucy_Test_Store_TestFileHandle_run);
1824 0 XS_INTERNAL(XS_Lucy_Test_Store_TestFileHandle_run) {
1825 0 dXSARGS;
1826 SV *sv;
1827 testlucy_TestFileHandle* arg_self;
1828 cfish_TestBatchRunner* arg_runner;
1829 TESTLUCY_TestFH_Run_t method;
1830  
1831 CFISH_UNUSED_VAR(cv);
1832 0 SP -= items;
1833 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1834 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1835 }
1836  
1837 /* Extract vars from Perl stack. */
1838 0 arg_self = (testlucy_TestFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFILEHANDLE, NULL);
1839 0 sv = ST(1);
1840 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1841  
1842 /* Execute */
1843 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFILEHANDLE, TESTLUCY_TestFH_Run);
1844 0 method(arg_self, arg_runner);
1845 0 XSRETURN(0);
1846 }
1847  
1848 XS_INTERNAL(XS_Lucy_Test_Store_TestFolder_run);
1849 0 XS_INTERNAL(XS_Lucy_Test_Store_TestFolder_run) {
1850 0 dXSARGS;
1851 SV *sv;
1852 testlucy_TestFolder* arg_self;
1853 cfish_TestBatchRunner* arg_runner;
1854 TESTLUCY_TestFolder_Run_t method;
1855  
1856 CFISH_UNUSED_VAR(cv);
1857 0 SP -= items;
1858 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1859 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1860 }
1861  
1862 /* Extract vars from Perl stack. */
1863 0 arg_self = (testlucy_TestFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFOLDER, NULL);
1864 0 sv = ST(1);
1865 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1866  
1867 /* Execute */
1868 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFOLDER, TESTLUCY_TestFolder_Run);
1869 0 method(arg_self, arg_runner);
1870 0 XSRETURN(0);
1871 }
1872  
1873 XS_INTERNAL(XS_Lucy_Test_Store_TestIOChunks_run);
1874 0 XS_INTERNAL(XS_Lucy_Test_Store_TestIOChunks_run) {
1875 0 dXSARGS;
1876 SV *sv;
1877 testlucy_TestIOChunks* arg_self;
1878 cfish_TestBatchRunner* arg_runner;
1879 TESTLUCY_TestIOChunks_Run_t method;
1880  
1881 CFISH_UNUSED_VAR(cv);
1882 0 SP -= items;
1883 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1884 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1885 }
1886  
1887 /* Extract vars from Perl stack. */
1888 0 arg_self = (testlucy_TestIOChunks*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTIOCHUNKS, NULL);
1889 0 sv = ST(1);
1890 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1891  
1892 /* Execute */
1893 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTIOCHUNKS, TESTLUCY_TestIOChunks_Run);
1894 0 method(arg_self, arg_runner);
1895 0 XSRETURN(0);
1896 }
1897  
1898 XS_INTERNAL(XS_Lucy_Test_Store_TestIOPrimitives_run);
1899 0 XS_INTERNAL(XS_Lucy_Test_Store_TestIOPrimitives_run) {
1900 0 dXSARGS;
1901 SV *sv;
1902 testlucy_TestIOPrimitives* arg_self;
1903 cfish_TestBatchRunner* arg_runner;
1904 TESTLUCY_TestIOPrimitives_Run_t method;
1905  
1906 CFISH_UNUSED_VAR(cv);
1907 0 SP -= items;
1908 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1909 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1910 }
1911  
1912 /* Extract vars from Perl stack. */
1913 0 arg_self = (testlucy_TestIOPrimitives*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTIOPRIMITIVES, NULL);
1914 0 sv = ST(1);
1915 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1916  
1917 /* Execute */
1918 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTIOPRIMITIVES, TESTLUCY_TestIOPrimitives_Run);
1919 0 method(arg_self, arg_runner);
1920 0 XSRETURN(0);
1921 }
1922  
1923 XS_INTERNAL(XS_Lucy_Test_Store_TestInStream_run);
1924 0 XS_INTERNAL(XS_Lucy_Test_Store_TestInStream_run) {
1925 0 dXSARGS;
1926 SV *sv;
1927 testlucy_TestInStream* arg_self;
1928 cfish_TestBatchRunner* arg_runner;
1929 TESTLUCY_TestInStream_Run_t method;
1930  
1931 CFISH_UNUSED_VAR(cv);
1932 0 SP -= items;
1933 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1934 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1935 }
1936  
1937 /* Extract vars from Perl stack. */
1938 0 arg_self = (testlucy_TestInStream*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINSTREAM, NULL);
1939 0 sv = ST(1);
1940 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1941  
1942 /* Execute */
1943 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTINSTREAM, TESTLUCY_TestInStream_Run);
1944 0 method(arg_self, arg_runner);
1945 0 XSRETURN(0);
1946 }
1947  
1948 XS_INTERNAL(XS_Lucy_Test_Store_TestLockFileLock_run);
1949 0 XS_INTERNAL(XS_Lucy_Test_Store_TestLockFileLock_run) {
1950 0 dXSARGS;
1951 SV *sv;
1952 testlucy_TestLockFileLock* arg_self;
1953 cfish_TestBatchRunner* arg_runner;
1954 TESTLUCY_TestLFLock_Run_t method;
1955  
1956 CFISH_UNUSED_VAR(cv);
1957 0 SP -= items;
1958 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1959 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1960 }
1961  
1962 /* Extract vars from Perl stack. */
1963 0 arg_self = (testlucy_TestLockFileLock*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTLOCKFILELOCK, NULL);
1964 0 sv = ST(1);
1965 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1966  
1967 /* Execute */
1968 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTLOCKFILELOCK, TESTLUCY_TestLFLock_Run);
1969 0 method(arg_self, arg_runner);
1970 0 XSRETURN(0);
1971 }
1972  
1973 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMDirHandle_run);
1974 0 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMDirHandle_run) {
1975 0 dXSARGS;
1976 SV *sv;
1977 testlucy_TestRAMDirHandle* arg_self;
1978 cfish_TestBatchRunner* arg_runner;
1979 TESTLUCY_TestRAMDH_Run_t method;
1980  
1981 CFISH_UNUSED_VAR(cv);
1982 0 SP -= items;
1983 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1984 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
1985 }
1986  
1987 /* Extract vars from Perl stack. */
1988 0 arg_self = (testlucy_TestRAMDirHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMDIRHANDLE, NULL);
1989 0 sv = ST(1);
1990 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
1991  
1992 /* Execute */
1993 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMDIRHANDLE, TESTLUCY_TestRAMDH_Run);
1994 0 method(arg_self, arg_runner);
1995 0 XSRETURN(0);
1996 }
1997  
1998 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFileHandle_run);
1999 0 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFileHandle_run) {
2000 0 dXSARGS;
2001 SV *sv;
2002 testlucy_TestRAMFileHandle* arg_self;
2003 cfish_TestBatchRunner* arg_runner;
2004 TESTLUCY_TestRAMFH_Run_t method;
2005  
2006 CFISH_UNUSED_VAR(cv);
2007 0 SP -= items;
2008 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2009 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2010 }
2011  
2012 /* Extract vars from Perl stack. */
2013 0 arg_self = (testlucy_TestRAMFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMFILEHANDLE, NULL);
2014 0 sv = ST(1);
2015 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2016  
2017 /* Execute */
2018 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMFILEHANDLE, TESTLUCY_TestRAMFH_Run);
2019 0 method(arg_self, arg_runner);
2020 0 XSRETURN(0);
2021 }
2022  
2023 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFolder_run);
2024 0 XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFolder_run) {
2025 0 dXSARGS;
2026 SV *sv;
2027 testlucy_TestRAMFolder* arg_self;
2028 cfish_TestBatchRunner* arg_runner;
2029 TESTLUCY_TestRAMFolder_Run_t method;
2030  
2031 CFISH_UNUSED_VAR(cv);
2032 0 SP -= items;
2033 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2034 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2035 }
2036  
2037 /* Extract vars from Perl stack. */
2038 0 arg_self = (testlucy_TestRAMFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMFOLDER, NULL);
2039 0 sv = ST(1);
2040 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2041  
2042 /* Execute */
2043 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMFOLDER, TESTLUCY_TestRAMFolder_Run);
2044 0 method(arg_self, arg_runner);
2045 0 XSRETURN(0);
2046 }
2047  
2048 XS_INTERNAL(XS_Lucy_Test_TestBatchSchema_run);
2049 0 XS_INTERNAL(XS_Lucy_Test_TestBatchSchema_run) {
2050 0 dXSARGS;
2051 SV *sv;
2052 testlucy_TestBatchSchema* arg_self;
2053 cfish_TestBatchRunner* arg_runner;
2054 TESTLUCY_TestBatchSchema_Run_t method;
2055  
2056 CFISH_UNUSED_VAR(cv);
2057 0 SP -= items;
2058 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2059 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2060 }
2061  
2062 /* Extract vars from Perl stack. */
2063 0 arg_self = (testlucy_TestBatchSchema*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBATCHSCHEMA, NULL);
2064 0 sv = ST(1);
2065 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2066  
2067 /* Execute */
2068 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTBATCHSCHEMA, TESTLUCY_TestBatchSchema_Run);
2069 0 method(arg_self, arg_runner);
2070 0 XSRETURN(0);
2071 }
2072  
2073 XS_INTERNAL(XS_Lucy_Test_TestSchema_new);
2074 46 XS_INTERNAL(XS_Lucy_Test_TestSchema_new) {
2075 46 dXSARGS;
2076 static const XSBind_ParamSpec param_specs[1] = {
2077 XSBIND_PARAM("use_alt_arch", 0)
2078 };
2079 int32_t locations[1];
2080 SV *sv;
2081 testlucy_TestSchema* arg_self;
2082 bool arg_use_alt_arch;
2083 testlucy_TestSchema* retval;
2084  
2085 CFISH_UNUSED_VAR(cv);
2086 46 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 46 46
2087 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
2088 }
2089 46 SP -= items;
2090  
2091 46 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
2092 locations, 1);
2093 46 sv = ST(locations[0]);
2094 46 ▶ arg_use_alt_arch = locations[0] < items && XSBind_sv_defined(aTHX_ sv)
Branch: 2 branches
BranchTrueFalseTotal
arg_use_alt_arch = locations[0] < items && XSBind_sv_defined(aTHX_ sv) 0 46 46
arg_use_alt_arch = locations[0] < items && XSBind_sv_defined(aTHX_ sv) 0 0 0
2095 46 ▶ ? XSBind_sv_true(aTHX_ sv) : false;
Branch: 2 branches
BranchTrueFalseTotal
? XSBind_sv_true(aTHX_ sv) : false; 0 46 46
? XSBind_sv_true(aTHX_ sv) : false; 0 0 0
2096 46 arg_self = (testlucy_TestSchema*)XSBind_new_blank_obj(aTHX_ ST(0));
2097  
2098 46 retval = testlucy_TestSchema_init(arg_self, arg_use_alt_arch);
2099 46 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
2100 46 XSRETURN(1);
2101 }
2102  
2103  
2104 XS_INTERNAL(XS_Lucy_Test_TestSchema_architecture);
2105 0 XS_INTERNAL(XS_Lucy_Test_TestSchema_architecture) {
2106 0 dXSARGS;
2107 testlucy_TestSchema* arg_self;
2108 TESTLUCY_TestSchema_Architecture_t method;
2109 lucy_Architecture* retval;
2110  
2111 CFISH_UNUSED_VAR(cv);
2112 0 SP -= items;
2113 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2114 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2115 }
2116  
2117 /* Extract vars from Perl stack. */
2118 0 arg_self = (testlucy_TestSchema*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSCHEMA, NULL);
2119  
2120 /* Execute */
2121 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSCHEMA, TESTLUCY_TestSchema_Architecture);
2122 0 retval = method(arg_self);
2123 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2124 0 CFISH_DECREF(retval);
2125 0 sv_2mortal( ST(0) );
2126 0 XSRETURN(1);
2127 }
2128  
2129 XS_INTERNAL(XS_Lucy_Test_TestSimple_run);
2130 0 XS_INTERNAL(XS_Lucy_Test_TestSimple_run) {
2131 0 dXSARGS;
2132 SV *sv;
2133 testlucy_TestSimple* arg_self;
2134 cfish_TestBatchRunner* arg_runner;
2135 TESTLUCY_TestSimple_Run_t method;
2136  
2137 CFISH_UNUSED_VAR(cv);
2138 0 SP -= items;
2139 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2140 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2141 }
2142  
2143 /* Extract vars from Perl stack. */
2144 0 arg_self = (testlucy_TestSimple*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSIMPLE, NULL);
2145 0 sv = ST(1);
2146 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2147  
2148 /* Execute */
2149 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSIMPLE, TESTLUCY_TestSimple_Run);
2150 0 method(arg_self, arg_runner);
2151 0 XSRETURN(0);
2152 }
2153  
2154 XS_INTERNAL(XS_Lucy_Test_Util_NumPriorityQueue_less_than);
2155 0 XS_INTERNAL(XS_Lucy_Test_Util_NumPriorityQueue_less_than) {
2156 0 dXSARGS;
2157 static const XSBind_ParamSpec param_specs[2] = {
2158 XSBIND_PARAM("a", 1),
2159 XSBIND_PARAM("b", 1)
2160 };
2161 int32_t locations[2];
2162 SV *sv;
2163 testlucy_NumPriorityQueue* arg_self;
2164 cfish_Obj* arg_a;
2165 cfish_Obj* arg_b;
2166 TESTLUCY_NumPriQ_Less_Than_t method;
2167 bool retval;
2168  
2169 CFISH_UNUSED_VAR(cv);
2170 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
2171 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
2172 }
2173 0 SP -= items;
2174  
2175 /* Locate args on Perl stack. */
2176 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
2177 locations, 2);
2178 0 arg_self = (testlucy_NumPriorityQueue*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_NUMPRIORITYQUEUE, NULL);
2179 0 sv = ST(locations[0]);
2180 0 arg_a = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "a", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2181 0 sv = ST(locations[1]);
2182 0 arg_b = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "b", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2183  
2184 /* Execute */
2185 0 method = CFISH_METHOD_PTR(TESTLUCY_NUMPRIORITYQUEUE, TESTLUCY_NumPriQ_Less_Than);
2186 0 retval = method(arg_self, arg_a, arg_b);
2187 0 ST(0) = newSViv(!!retval);
2188 0 sv_2mortal( ST(0) );
2189 0 XSRETURN(1);
2190 }
2191  
2192 XS_INTERNAL(XS_Lucy_Test_Util_TestFreezer_run);
2193 0 XS_INTERNAL(XS_Lucy_Test_Util_TestFreezer_run) {
2194 0 dXSARGS;
2195 SV *sv;
2196 testlucy_TestFreezer* arg_self;
2197 cfish_TestBatchRunner* arg_runner;
2198 TESTLUCY_TestFreezer_Run_t method;
2199  
2200 CFISH_UNUSED_VAR(cv);
2201 0 SP -= items;
2202 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2203 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2204 }
2205  
2206 /* Extract vars from Perl stack. */
2207 0 arg_self = (testlucy_TestFreezer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFREEZER, NULL);
2208 0 sv = ST(1);
2209 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2210  
2211 /* Execute */
2212 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTFREEZER, TESTLUCY_TestFreezer_Run);
2213 0 method(arg_self, arg_runner);
2214 0 XSRETURN(0);
2215 }
2216  
2217 XS_INTERNAL(XS_Lucy_Test_Util_TestIndexFileNames_run);
2218 0 XS_INTERNAL(XS_Lucy_Test_Util_TestIndexFileNames_run) {
2219 0 dXSARGS;
2220 SV *sv;
2221 testlucy_TestIndexFileNames* arg_self;
2222 cfish_TestBatchRunner* arg_runner;
2223 TESTLUCY_TestIxFileNames_Run_t method;
2224  
2225 CFISH_UNUSED_VAR(cv);
2226 0 SP -= items;
2227 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2228 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2229 }
2230  
2231 /* Extract vars from Perl stack. */
2232 0 arg_self = (testlucy_TestIndexFileNames*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINDEXFILENAMES, NULL);
2233 0 sv = ST(1);
2234 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2235  
2236 /* Execute */
2237 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTINDEXFILENAMES, TESTLUCY_TestIxFileNames_Run);
2238 0 method(arg_self, arg_runner);
2239 0 XSRETURN(0);
2240 }
2241  
2242 XS_INTERNAL(XS_Lucy_Test_Util_TestJson_run);
2243 0 XS_INTERNAL(XS_Lucy_Test_Util_TestJson_run) {
2244 0 dXSARGS;
2245 SV *sv;
2246 testlucy_TestJson* arg_self;
2247 cfish_TestBatchRunner* arg_runner;
2248 TESTLUCY_TestJson_Run_t method;
2249  
2250 CFISH_UNUSED_VAR(cv);
2251 0 SP -= items;
2252 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2253 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2254 }
2255  
2256 /* Extract vars from Perl stack. */
2257 0 arg_self = (testlucy_TestJson*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTJSON, NULL);
2258 0 sv = ST(1);
2259 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2260  
2261 /* Execute */
2262 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTJSON, TESTLUCY_TestJson_Run);
2263 0 method(arg_self, arg_runner);
2264 0 XSRETURN(0);
2265 }
2266  
2267 XS_INTERNAL(XS_Lucy_Test_Util_TestMemoryPool_run);
2268 0 XS_INTERNAL(XS_Lucy_Test_Util_TestMemoryPool_run) {
2269 0 dXSARGS;
2270 SV *sv;
2271 testlucy_TestMemoryPool* arg_self;
2272 cfish_TestBatchRunner* arg_runner;
2273 TESTLUCY_TestMemPool_Run_t method;
2274  
2275 CFISH_UNUSED_VAR(cv);
2276 0 SP -= items;
2277 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2278 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2279 }
2280  
2281 /* Extract vars from Perl stack. */
2282 0 arg_self = (testlucy_TestMemoryPool*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTMEMORYPOOL, NULL);
2283 0 sv = ST(1);
2284 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2285  
2286 /* Execute */
2287 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTMEMORYPOOL, TESTLUCY_TestMemPool_Run);
2288 0 method(arg_self, arg_runner);
2289 0 XSRETURN(0);
2290 }
2291  
2292 XS_INTERNAL(XS_Lucy_Test_Util_TestNumberUtils_run);
2293 0 XS_INTERNAL(XS_Lucy_Test_Util_TestNumberUtils_run) {
2294 0 dXSARGS;
2295 SV *sv;
2296 testlucy_TestNumberUtils* arg_self;
2297 cfish_TestBatchRunner* arg_runner;
2298 TESTLUCY_TestNumUtil_Run_t method;
2299  
2300 CFISH_UNUSED_VAR(cv);
2301 0 SP -= items;
2302 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2303 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2304 }
2305  
2306 /* Extract vars from Perl stack. */
2307 0 arg_self = (testlucy_TestNumberUtils*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNUMBERUTILS, NULL);
2308 0 sv = ST(1);
2309 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2310  
2311 /* Execute */
2312 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTNUMBERUTILS, TESTLUCY_TestNumUtil_Run);
2313 0 method(arg_self, arg_runner);
2314 0 XSRETURN(0);
2315 }
2316  
2317 XS_INTERNAL(XS_Lucy_Test_Util_TestPriorityQueue_run);
2318 0 XS_INTERNAL(XS_Lucy_Test_Util_TestPriorityQueue_run) {
2319 0 dXSARGS;
2320 SV *sv;
2321 testlucy_TestPriorityQueue* arg_self;
2322 cfish_TestBatchRunner* arg_runner;
2323 TESTLUCY_TestPriQ_Run_t method;
2324  
2325 CFISH_UNUSED_VAR(cv);
2326 0 SP -= items;
2327 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2328 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2329 }
2330  
2331 /* Extract vars from Perl stack. */
2332 0 arg_self = (testlucy_TestPriorityQueue*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPRIORITYQUEUE, NULL);
2333 0 sv = ST(1);
2334 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2335  
2336 /* Execute */
2337 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTPRIORITYQUEUE, TESTLUCY_TestPriQ_Run);
2338 0 method(arg_self, arg_runner);
2339 0 XSRETURN(0);
2340 }
2341  
2342 XS_INTERNAL(XS_Lucy_Test_Util_TestSortExternal_run);
2343 0 XS_INTERNAL(XS_Lucy_Test_Util_TestSortExternal_run) {
2344 0 dXSARGS;
2345 SV *sv;
2346 testlucy_TestSortExternal* arg_self;
2347 cfish_TestBatchRunner* arg_runner;
2348 TESTLUCY_TestSortExternal_Run_t method;
2349  
2350 CFISH_UNUSED_VAR(cv);
2351 0 SP -= items;
2352 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2353 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2354 }
2355  
2356 /* Extract vars from Perl stack. */
2357 0 arg_self = (testlucy_TestSortExternal*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTEXTERNAL, NULL);
2358 0 sv = ST(1);
2359 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2360  
2361 /* Execute */
2362 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTEXTERNAL, TESTLUCY_TestSortExternal_Run);
2363 0 method(arg_self, arg_runner);
2364 0 XSRETURN(0);
2365 }
2366  
2367 XS_INTERNAL(XS_Lucy_Test_Util_TestStringHelper_run);
2368 0 XS_INTERNAL(XS_Lucy_Test_Util_TestStringHelper_run) {
2369 0 dXSARGS;
2370 SV *sv;
2371 testlucy_TestStringHelper* arg_self;
2372 cfish_TestBatchRunner* arg_runner;
2373 TESTLUCY_TestStrHelp_Run_t method;
2374  
2375 CFISH_UNUSED_VAR(cv);
2376 0 SP -= items;
2377 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2378 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2379 }
2380  
2381 /* Extract vars from Perl stack. */
2382 0 arg_self = (testlucy_TestStringHelper*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSTRINGHELPER, NULL);
2383 0 sv = ST(1);
2384 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2385  
2386 /* Execute */
2387 0 method = CFISH_METHOD_PTR(TESTLUCY_TESTSTRINGHELPER, TESTLUCY_TestStrHelp_Run);
2388 0 method(arg_self, arg_runner);
2389 0 XSRETURN(0);
2390 }
2391  
2392  
2393 MODULE = Lucy::Test PACKAGE = Lucy::Test
2394  
2395 BOOT:
2396 {
2397 static const cfish_XSBind_ClassSpec class_specs[] = {
2398 { "Lucy::Store::MockFileHandle", "Lucy::Store::FileHandle", 5 },
2399 { "Lucy::Test::Analysis::DummyAnalyzer", "Lucy::Analysis::Analyzer", 2 },
2400 { "Lucy::Test::Analysis::TestAnalyzer", "Clownfish::TestHarness::TestBatch", 1 },
2401 { "Lucy::Test::Analysis::TestCaseFolder", "Clownfish::TestHarness::TestBatch", 1 },
2402 { "Lucy::Test::Analysis::TestNormalizer", "Clownfish::TestHarness::TestBatch", 1 },
2403 { "Lucy::Test::Analysis::TestPolyAnalyzer", "Clownfish::TestHarness::TestBatch", 1 },
2404 { "Lucy::Test::Analysis::TestRegexTokenizer", "Clownfish::TestHarness::TestBatch", 1 },
2405 { "Lucy::Test::Analysis::TestSnowballStemmer", "Clownfish::TestHarness::TestBatch", 1 },
2406 { "Lucy::Test::Analysis::TestSnowballStopFilter", "Clownfish::TestHarness::TestBatch", 1 },
2407 { "Lucy::Test::Analysis::TestStandardTokenizer", "Clownfish::TestHarness::TestBatch", 1 },
2408 { "Lucy::Test::Highlight::TestHeatMap", "Clownfish::TestHarness::TestBatch", 1 },
2409 { "Lucy::Test::Highlight::TestHighlighter", "Clownfish::TestHarness::TestBatch", 1 },
2410 { "Lucy::Test::Index::NoMergeManager", "Lucy::Index::IndexManager", 1 },
2411 { "Lucy::Test::Index::TestBackgroundMerger", "Clownfish::TestHarness::TestBatch", 1 },
2412 { "Lucy::Test::Index::TestDocWriter", "Clownfish::TestHarness::TestBatch", 1 },
2413 { "Lucy::Test::Index::TestHighlightWriter", "Clownfish::TestHarness::TestBatch", 1 },
2414 { "Lucy::Test::Index::TestIndexManager", "Clownfish::TestHarness::TestBatch", 1 },
2415 { "Lucy::Test::Index::TestPolyReader", "Clownfish::TestHarness::TestBatch", 1 },
2416 { "Lucy::Test::Index::TestPostingListWriter", "Clownfish::TestHarness::TestBatch", 1 },
2417 { "Lucy::Test::Index::TestSegWriter", "Clownfish::TestHarness::TestBatch", 1 },
2418 { "Lucy::Test::Index::TestSegment", "Clownfish::TestHarness::TestBatch", 1 },
2419 { "Lucy::Test::Index::TestSnapshot", "Clownfish::TestHarness::TestBatch", 1 },
2420 { "Lucy::Test::Index::TestSortWriter", "Clownfish::TestHarness::TestBatch", 1 },
2421 { "Lucy::Test::Index::TestTermInfo", "Clownfish::TestHarness::TestBatch", 1 },
2422 { "Lucy::Test::Object::TestBitVector", "Clownfish::TestHarness::TestBatch", 1 },
2423 { "Lucy::Test::Object::TestI32Array", "Clownfish::TestHarness::TestBatch", 1 },
2424 { "Lucy::Test::Plan::DummyFieldType", "Lucy::Plan::FieldType", 0 },
2425 { "Lucy::Test::Plan::TestArchitecture", "Lucy::Plan::Architecture", 3 },
2426 { "Lucy::Test::Plan::TestBlobType", "Clownfish::TestHarness::TestBatch", 1 },
2427 { "Lucy::Test::Plan::TestFieldMisc", "Clownfish::TestHarness::TestBatch", 1 },
2428 { "Lucy::Test::Plan::TestFieldType", "Clownfish::TestHarness::TestBatch", 1 },
2429 { "Lucy::Test::Plan::TestFullTextType", "Clownfish::TestHarness::TestBatch", 1 },
2430 { "Lucy::Test::Plan::TestNumericType", "Clownfish::TestHarness::TestBatch", 1 },
2431 { "Lucy::Test::Search::TestANDQuery", "Clownfish::TestHarness::TestBatch", 1 },
2432 { "Lucy::Test::Search::TestLeafQuery", "Clownfish::TestHarness::TestBatch", 1 },
2433 { "Lucy::Test::Search::TestMatchAllQuery", "Clownfish::TestHarness::TestBatch", 1 },
2434 { "Lucy::Test::Search::TestNOTQuery", "Clownfish::TestHarness::TestBatch", 1 },
2435 { "Lucy::Test::Search::TestNoMatchQuery", "Clownfish::TestHarness::TestBatch", 1 },
2436 { "Lucy::Test::Search::TestORQuery", "Clownfish::TestHarness::TestBatch", 1 },
2437 { "Lucy::Test::Search::TestPhraseQuery", "Clownfish::TestHarness::TestBatch", 1 },
2438 { "Lucy::Test::Search::TestPolySearcher", "Clownfish::TestHarness::TestBatch", 1 },
2439 { "Lucy::Test::Search::TestQueryParser", "Clownfish::Obj", 4 },
2440 { "Lucy::Test::Search::TestQueryParserLogic", "Clownfish::TestHarness::TestBatch", 1 },
2441 { "Lucy::Test::Search::TestQueryParserSyntax", "Clownfish::TestHarness::TestBatch", 1 },
2442 { "Lucy::Test::Search::TestRangeQuery", "Clownfish::TestHarness::TestBatch", 1 },
2443 { "Lucy::Test::Search::TestReqOptQuery", "Clownfish::TestHarness::TestBatch", 1 },
2444 { "Lucy::Test::Search::TestReverseType", "Lucy::Plan::Int32Type", 2 },
2445 { "Lucy::Test::Search::TestSeriesMatcher", "Clownfish::TestHarness::TestBatch", 1 },
2446 { "Lucy::Test::Search::TestSortSpec", "Clownfish::TestHarness::TestBatch", 1 },
2447 { "Lucy::Test::Search::TestSpan", "Clownfish::TestHarness::TestBatch", 1 },
2448 { "Lucy::Test::Search::TestTermQuery", "Clownfish::TestHarness::TestBatch", 1 },
2449 { "Lucy::Test::Store::TestCompoundFileReader", "Clownfish::TestHarness::TestBatch", 1 },
2450 { "Lucy::Test::Store::TestCompoundFileWriter", "Clownfish::TestHarness::TestBatch", 1 },
2451 { "Lucy::Test::Store::TestFSDirHandle", "Clownfish::TestHarness::TestBatch", 1 },
2452 { "Lucy::Test::Store::TestFSFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
2453 { "Lucy::Test::Store::TestFSFolder", "Clownfish::TestHarness::TestBatch", 1 },
2454 { "Lucy::Test::Store::TestFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
2455 { "Lucy::Test::Store::TestFolder", "Clownfish::TestHarness::TestBatch", 1 },
2456 { "Lucy::Test::Store::TestIOChunks", "Clownfish::TestHarness::TestBatch", 1 },
2457 { "Lucy::Test::Store::TestIOPrimitives", "Clownfish::TestHarness::TestBatch", 1 },
2458 { "Lucy::Test::Store::TestInStream", "Clownfish::TestHarness::TestBatch", 1 },
2459 { "Lucy::Test::Store::TestLockFileLock", "Clownfish::TestHarness::TestBatch", 1 },
2460 { "Lucy::Test::Store::TestRAMDirHandle", "Clownfish::TestHarness::TestBatch", 1 },
2461 { "Lucy::Test::Store::TestRAMFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
2462 { "Lucy::Test::Store::TestRAMFolder", "Clownfish::TestHarness::TestBatch", 1 },
2463 { "Lucy::Test::TestBatchSchema", "Clownfish::TestHarness::TestBatch", 1 },
2464 { "Lucy::Test::TestSchema", "Lucy::Plan::Schema", 2 },
2465 { "Lucy::Test::TestSimple", "Clownfish::TestHarness::TestBatch", 1 },
2466 { "Lucy::Test::Util::NumPriorityQueue", "Lucy::Util::PriorityQueue", 1 },
2467 { "Lucy::Test::Util::TestFreezer", "Clownfish::TestHarness::TestBatch", 1 },
2468 { "Lucy::Test::Util::TestIndexFileNames", "Clownfish::TestHarness::TestBatch", 1 },
2469 { "Lucy::Test::Util::TestJson", "Clownfish::TestHarness::TestBatch", 1 },
2470 { "Lucy::Test::Util::TestMemoryPool", "Clownfish::TestHarness::TestBatch", 1 },
2471 { "Lucy::Test::Util::TestNumberUtils", "Clownfish::TestHarness::TestBatch", 1 },
2472 { "Lucy::Test::Util::TestPriorityQueue", "Clownfish::TestHarness::TestBatch", 1 },
2473 { "Lucy::Test::Util::TestSortExternal", "Clownfish::TestHarness::TestBatch", 1 },
2474 { "Lucy::Test::Util::TestStringHelper", "Clownfish::TestHarness::TestBatch", 1 }
2475 };
2476 static const cfish_XSBind_XSubSpec xsub_specs[] = {
2477 { "new", XS_Lucy_Store_MockFileHandle_new },
2478 { "window", XS_Lucy_Store_MockFileHandle_window },
2479 { "release_window", XS_Lucy_Store_MockFileHandle_release_window },
2480 { "length", XS_Lucy_Store_MockFileHandle_length },
2481 { "close", XS_Lucy_Store_MockFileHandle_close },
2482 { "new", XS_Lucy_Test_Analysis_DummyAnalyzer_new },
2483 { "transform", XS_Lucy_Test_Analysis_DummyAnalyzer_transform },
2484 { "run", XS_Lucy_Test_Analysis_TestAnalyzer_run },
2485 { "run", XS_Lucy_Test_Analysis_TestCaseFolder_run },
2486 { "run", XS_Lucy_Test_Analysis_TestNormalizer_run },
2487 { "run", XS_Lucy_Test_Analysis_TestPolyAnalyzer_run },
2488 { "run", XS_Lucy_Test_Analysis_TestRegexTokenizer_run },
2489 { "run", XS_Lucy_Test_Analysis_TestSnowballStemmer_run },
2490 { "run", XS_Lucy_Test_Analysis_TestSnowballStopFilter_run },
2491 { "run", XS_Lucy_Test_Analysis_TestStandardTokenizer_run },
2492 { "run", XS_Lucy_Test_Highlight_TestHeatMap_run },
2493 { "run", XS_Lucy_Test_Highlight_TestHighlighter_run },
2494 { "recycle", XS_Lucy_Test_Index_NoMergeManager_recycle },
2495 { "run", XS_Lucy_Test_Index_TestBackgroundMerger_run },
2496 { "run", XS_Lucy_Test_Index_TestDocWriter_run },
2497 { "run", XS_Lucy_Test_Index_TestHighlightWriter_run },
2498 { "run", XS_Lucy_Test_Index_TestIndexManager_run },
2499 { "run", XS_Lucy_Test_Index_TestPolyReader_run },
2500 { "run", XS_Lucy_Test_Index_TestPostingListWriter_run },
2501 { "run", XS_Lucy_Test_Index_TestSegWriter_run },
2502 { "run", XS_Lucy_Test_Index_TestSegment_run },
2503 { "run", XS_Lucy_Test_Index_TestSnapshot_run },
2504 { "run", XS_Lucy_Test_Index_TestSortWriter_run },
2505 { "run", XS_Lucy_Test_Index_TestTermInfo_run },
2506 { "run", XS_Lucy_Test_Object_TestBitVector_run },
2507 { "run", XS_Lucy_Test_Object_TestI32Array_run },
2508 { "new", XS_Lucy_Test_Plan_TestArchitecture_new },
2509 { "index_interval", XS_Lucy_Test_Plan_TestArchitecture_index_interval },
2510 { "skip_interval", XS_Lucy_Test_Plan_TestArchitecture_skip_interval },
2511 { "run", XS_Lucy_Test_Plan_TestBlobType_run },
2512 { "run", XS_Lucy_Test_Plan_TestFieldMisc_run },
2513 { "run", XS_Lucy_Test_Plan_TestFieldType_run },
2514 { "run", XS_Lucy_Test_Plan_TestFullTextType_run },
2515 { "run", XS_Lucy_Test_Plan_TestNumericType_run },
2516 { "run", XS_Lucy_Test_Search_TestANDQuery_run },
2517 { "run", XS_Lucy_Test_Search_TestLeafQuery_run },
2518 { "run", XS_Lucy_Test_Search_TestMatchAllQuery_run },
2519 { "run", XS_Lucy_Test_Search_TestNOTQuery_run },
2520 { "run", XS_Lucy_Test_Search_TestNoMatchQuery_run },
2521 { "run", XS_Lucy_Test_Search_TestORQuery_run },
2522 { "run", XS_Lucy_Test_Search_TestPhraseQuery_run },
2523 { "run", XS_Lucy_Test_Search_TestPolySearcher_run },
2524 { "get_query_string", XS_Lucy_Test_Search_TestQueryParser_get_query_string },
2525 { "get_tree", XS_Lucy_Test_Search_TestQueryParser_get_tree },
2526 { "get_expanded", XS_Lucy_Test_Search_TestQueryParser_get_expanded },
2527 { "get_num_hits", XS_Lucy_Test_Search_TestQueryParser_get_num_hits },
2528 { "run", XS_Lucy_Test_Search_TestQueryParserLogic_run },
2529 { "run", XS_Lucy_Test_Search_TestQueryParserSyntax_run },
2530 { "run", XS_Lucy_Test_Search_TestRangeQuery_run },
2531 { "run", XS_Lucy_Test_Search_TestReqOptQuery_run },
2532 { "new", XS_Lucy_Test_Search_TestReverseType_new },
2533 { "compare_values", XS_Lucy_Test_Search_TestReverseType_compare_values },
2534 { "run", XS_Lucy_Test_Search_TestSeriesMatcher_run },
2535 { "run", XS_Lucy_Test_Search_TestSortSpec_run },
2536 { "run", XS_Lucy_Test_Search_TestSpan_run },
2537 { "run", XS_Lucy_Test_Search_TestTermQuery_run },
2538 { "run", XS_Lucy_Test_Store_TestCompoundFileReader_run },
2539 { "run", XS_Lucy_Test_Store_TestCompoundFileWriter_run },
2540 { "run", XS_Lucy_Test_Store_TestFSDirHandle_run },
2541 { "run", XS_Lucy_Test_Store_TestFSFileHandle_run },
2542 { "run", XS_Lucy_Test_Store_TestFSFolder_run },
2543 { "run", XS_Lucy_Test_Store_TestFileHandle_run },
2544 { "run", XS_Lucy_Test_Store_TestFolder_run },
2545 { "run", XS_Lucy_Test_Store_TestIOChunks_run },
2546 { "run", XS_Lucy_Test_Store_TestIOPrimitives_run },
2547 { "run", XS_Lucy_Test_Store_TestInStream_run },
2548 { "run", XS_Lucy_Test_Store_TestLockFileLock_run },
2549 { "run", XS_Lucy_Test_Store_TestRAMDirHandle_run },
2550 { "run", XS_Lucy_Test_Store_TestRAMFileHandle_run },
2551 { "run", XS_Lucy_Test_Store_TestRAMFolder_run },
2552 { "run", XS_Lucy_Test_TestBatchSchema_run },
2553 { "new", XS_Lucy_Test_TestSchema_new },
2554 { "architecture", XS_Lucy_Test_TestSchema_architecture },
2555 { "run", XS_Lucy_Test_TestSimple_run },
2556 { "less_than", XS_Lucy_Test_Util_NumPriorityQueue_less_than },
2557 { "run", XS_Lucy_Test_Util_TestFreezer_run },
2558 { "run", XS_Lucy_Test_Util_TestIndexFileNames_run },
2559 { "run", XS_Lucy_Test_Util_TestJson_run },
2560 { "run", XS_Lucy_Test_Util_TestMemoryPool_run },
2561 { "run", XS_Lucy_Test_Util_TestNumberUtils_run },
2562 { "run", XS_Lucy_Test_Util_TestPriorityQueue_run },
2563 { "run", XS_Lucy_Test_Util_TestSortExternal_run },
2564 { "run", XS_Lucy_Test_Util_TestStringHelper_run }
2565 };
2566 146 size_t num_classes
2567 = sizeof(class_specs) / sizeof(class_specs[0]);
2568 146 const char* file = __FILE__;
2569  
2570 146 testlucy_bootstrap_perl();
2571  
2572 146 cfish_XSBind_bootstrap(aTHX_ num_classes, class_specs,
2573 xsub_specs, file);
2574 }
2575  
2576 MODULE = Lucy::Test PACKAGE = Lucy::Test
2577  
2578 #include "Clownfish/TestHarness/TestFormatter.h"
2579 #include "Clownfish/TestHarness/TestSuite.h"
2580  
2581 bool
2582 run_tests(package)
2583 char *package;
2584 CODE:
2585 68 cfish_String *class_name = cfish_Str_newf("%s", package);
2586 cfish_TestFormatter *formatter
2587 68 = (cfish_TestFormatter*)cfish_TestFormatterTAP_new();
2588 68 cfish_TestSuite *suite = testlucy_Test_create_test_suite();
2589 68 bool result = CFISH_TestSuite_Run_Batch(suite, class_name, formatter);
2590 68 CFISH_DECREF(class_name);
2591 68 CFISH_DECREF(formatter);
2592 68 CFISH_DECREF(suite);
2593  
2594 68 ▶ RETVAL = result;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = result; 0 68 68
2595 OUTPUT: RETVAL
2596  
2597  
« autogen/include/Lucy/Index/SortCache.h ↑ Summary lib/Lucy.xs »