/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.45 from the
 * contents of Test.xs. Do not edit this file, edit Test.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "lib/Lucy/Test.xs"
/*
 * ***********************************************
 * 
 * !!!! DO NOT EDIT !!!!
 * 
 * This file was auto-generated by Build.PL.
 * 
 * ***********************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define CFP_TESTLUCY

#include "XSBind.h"
#include "testlucy_perl.h"
#include "Lucy/Test/TestUtils.h"
#include "Lucy/Test/Store/TestFolderCommon.h"
#include "Lucy/Test.h"
#include "Lucy/Test/Analysis/TestAnalyzer.h"
#include "Lucy/Test/Util/TestPriorityQueue.h"
#include "Lucy/Test/Search/TestSortSpec.h"
#include "Lucy/Test/Plan/TestFieldType.h"
#include "Lucy/Test/TestSchema.h"
#include "Lucy/Test/Plan/TestArchitecture.h"
#include "Lucy/Test/Index/TestSortWriter.h"
#include "Lucy/Test/Store/MockFileHandle.h"
#include "Lucy/Test/Search/TestQueryParser.h"
#include "Lucy/Test/Analysis/TestStandardTokenizer.h"
#include "Lucy/Test/Analysis/TestAnalyzer.h"
#include "Lucy/Test/Analysis/TestRegexTokenizer.h"
#include "Lucy/Test/Analysis/TestNormalizer.h"
#include "Lucy/Test/Analysis/TestSnowballStopFilter.h"
#include "Lucy/Test/Analysis/TestSnowballStemmer.h"
#include "Lucy/Test/Analysis/TestPolyAnalyzer.h"
#include "Lucy/Test/Analysis/TestCaseFolder.h"
#include "Lucy/Test/Util/TestPriorityQueue.h"
#include "Lucy/Test/Util/TestIndexFileNames.h"
#include "Lucy/Test/Util/TestSortExternal.h"
#include "Lucy/Test/Util/TestMemoryPool.h"
#include "Lucy/Test/Util/TestStringHelper.h"
#include "Lucy/Test/Util/TestNumberUtils.h"
#include "Lucy/Test/Util/TestFreezer.h"
#include "Lucy/Test/Util/TestJson.h"
#include "Lucy/Test/Highlight/TestHighlighter.h"
#include "Lucy/Test/Highlight/TestHeatMap.h"
#include "Lucy/Test/Plan/TestFullTextType.h"
#include "Lucy/Test/Plan/TestFieldMisc.h"
#include "Lucy/Test/Plan/TestFieldType.h"
#include "Lucy/Test/Plan/TestNumericType.h"
#include "Lucy/Test/Plan/TestBlobType.h"
#include "Lucy/Test/Search/TestLeafQuery.h"
#include "Lucy/Test/Search/TestNOTQuery.h"
#include "Lucy/Test/Search/TestRangeQuery.h"
#include "Lucy/Test/Search/TestPolyQuery.h"
#include "Lucy/Test/Search/TestPolyQuery.h"
#include "Lucy/Test/Search/TestQueryParserLogic.h"
#include "Lucy/Test/Search/TestReqOptQuery.h"
#include "Lucy/Test/Search/TestPhraseQuery.h"
#include "Lucy/Test/Search/TestQueryParserSyntax.h"
#include "Lucy/Test/Search/TestSeriesMatcher.h"
#include "Lucy/Test/Search/TestMatchAllQuery.h"
#include "Lucy/Test/Search/TestTermQuery.h"
#include "Lucy/Test/Search/TestNoMatchQuery.h"
#include "Lucy/Test/Search/TestSortSpec.h"
#include "Lucy/Test/Search/TestSpan.h"
#include "Lucy/Test/Object/TestBitVector.h"
#include "Lucy/Test/Object/TestI32Array.h"
#include "Lucy/Test/TestSchema.h"
#include "Lucy/Test/Index/TestSegWriter.h"
#include "Lucy/Test/Index/TestSnapshot.h"
#include "Lucy/Test/Index/TestSortWriter.h"
#include "Lucy/Test/Index/TestSegment.h"
#include "Lucy/Test/Index/TestDocWriter.h"
#include "Lucy/Test/Index/TestTermInfo.h"
#include "Lucy/Test/Index/TestPostingListWriter.h"
#include "Lucy/Test/Index/TestIndexManager.h"
#include "Lucy/Test/Index/TestPolyReader.h"
#include "Lucy/Test/Index/TestHighlightWriter.h"
#include "Lucy/Test/TestSimple.h"
#include "Lucy/Test/Store/TestFSDirHandle.h"
#include "Lucy/Test/Store/TestInStream.h"
#include "Lucy/Test/Store/TestFSFileHandle.h"
#include "Lucy/Test/Store/TestIOChunks.h"
#include "Lucy/Test/Store/TestFSFolder.h"
#include "Lucy/Test/Store/TestRAMFileHandle.h"
#include "Lucy/Test/Store/TestIOPrimitives.h"
#include "Lucy/Test/Store/TestCompoundFileWriter.h"
#include "Lucy/Test/Store/TestRAMDirHandle.h"
#include "Lucy/Test/Store/TestRAMFolder.h"
#include "Lucy/Test/Store/TestCompoundFileReader.h"
#include "Lucy/Test/Store/TestFileHandle.h"
#include "Lucy/Test/Store/TestFolder.h"

#ifndef XS_INTERNAL
  #define XS_INTERNAL XS
#endif

XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_new);
XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_new) {
    dXSARGS;
    testlucy_DummyAnalyzer* arg_self;
    testlucy_DummyAnalyzer* retval;

    CFISH_UNUSED_VAR(cv);
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    arg_self = (testlucy_DummyAnalyzer*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_DummyAnalyzer_init(arg_self);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_transform);
XS_INTERNAL(XS_Lucy_Test_Analysis_DummyAnalyzer_transform) {
    dXSARGS;
    SV *sv;
    testlucy_DummyAnalyzer* arg_self;
    lucy_Inversion* arg_inversion;
    TESTLUCY_DummyAnalyzer_Transform_t method;
    lucy_Inversion* retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, inversion");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_DummyAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_DUMMYANALYZER, NULL);
    sv = ST(1);
    arg_inversion = (lucy_Inversion*)XSBind_arg_to_cfish(aTHX_ sv, "inversion", LUCY_INVERSION, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_DUMMYANALYZER, TESTLUCY_DummyAnalyzer_Transform);
    retval = method(arg_self, arg_inversion);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    CFISH_DECREF(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Util_NumPriorityQueue_less_than);
XS_INTERNAL(XS_Lucy_Test_Util_NumPriorityQueue_less_than) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[2] = {
        XSBIND_PARAM("a", 1),
        XSBIND_PARAM("b", 1)
    };
    int32_t locations[2];
    SV *sv;
    testlucy_NumPriorityQueue* arg_self;
    cfish_Obj* arg_a;
    cfish_Obj* arg_b;
    TESTLUCY_NumPriQ_Less_Than_t method;
    bool retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self, ...");
    }
    SP -= items;

    /* Locate args on Perl stack. */
    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 2);
    arg_self = (testlucy_NumPriorityQueue*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_NUMPRIORITYQUEUE, NULL);
    sv = ST(locations[0]);
    arg_a = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "a", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
    sv = ST(locations[1]);
    arg_b = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "b", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_NUMPRIORITYQUEUE, TESTLUCY_NumPriQ_Less_Than);
    retval = method(arg_self, arg_a, arg_b);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_new);
XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_new) {
    dXSARGS;
    testlucy_TestReverseType* arg_self;
    testlucy_TestReverseType* retval;

    CFISH_UNUSED_VAR(cv);
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    arg_self = (testlucy_TestReverseType*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_TestReverseType_init(arg_self);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_compare_values);
XS_INTERNAL(XS_Lucy_Test_Search_TestReverseType_compare_values) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[2] = {
        XSBIND_PARAM("a", 1),
        XSBIND_PARAM("b", 1)
    };
    int32_t locations[2];
    SV *sv;
    testlucy_TestReverseType* arg_self;
    cfish_Obj* arg_a;
    cfish_Obj* arg_b;
    TESTLUCY_TestReverseType_Compare_Values_t method;
    int32_t retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self, ...");
    }
    SP -= items;

    /* Locate args on Perl stack. */
    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 2);
    arg_self = (testlucy_TestReverseType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREVERSETYPE, NULL);
    sv = ST(locations[0]);
    arg_a = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "a", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
    sv = ST(locations[1]);
    arg_b = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "b", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTREVERSETYPE, TESTLUCY_TestReverseType_Compare_Values);
    retval = method(arg_self, arg_a, arg_b);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_TestSchema_new);
XS_INTERNAL(XS_Lucy_Test_TestSchema_new) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[1] = {
        XSBIND_PARAM("use_alt_arch", 0)
    };
    int32_t locations[1];
    SV *sv;
    testlucy_TestSchema* arg_self;
    bool arg_use_alt_arch;
    testlucy_TestSchema* retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 1);
    sv = ST(locations[0]);
    arg_use_alt_arch = locations[0] < items && XSBind_sv_defined(aTHX_ sv)
             ? XSBind_sv_true(aTHX_ sv) : false;
    arg_self = (testlucy_TestSchema*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_TestSchema_init(arg_self, arg_use_alt_arch);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Test_TestSchema_architecture);
XS_INTERNAL(XS_Lucy_Test_TestSchema_architecture) {
    dXSARGS;
    testlucy_TestSchema* arg_self;
    TESTLUCY_TestSchema_Architecture_t method;
    lucy_Architecture* retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSchema*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSCHEMA, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSCHEMA, TESTLUCY_TestSchema_Architecture);
    retval = method(arg_self);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    CFISH_DECREF(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_new);
XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_new) {
    dXSARGS;
    testlucy_TestArchitecture* arg_self;
    testlucy_TestArchitecture* retval;

    CFISH_UNUSED_VAR(cv);
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    arg_self = (testlucy_TestArchitecture*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_TestArch_init(arg_self);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_index_interval);
XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_index_interval) {
    dXSARGS;
    testlucy_TestArchitecture* arg_self;
    TESTLUCY_TestArch_Index_Interval_t method;
    int32_t retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestArchitecture*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTARCHITECTURE, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTARCHITECTURE, TESTLUCY_TestArch_Index_Interval);
    retval = method(arg_self);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_skip_interval);
XS_INTERNAL(XS_Lucy_Test_Plan_TestArchitecture_skip_interval) {
    dXSARGS;
    testlucy_TestArchitecture* arg_self;
    TESTLUCY_TestArch_Skip_Interval_t method;
    int32_t retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestArchitecture*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTARCHITECTURE, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTARCHITECTURE, TESTLUCY_TestArch_Skip_Interval);
    retval = method(arg_self);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Index_NonMergingIndexManager_new);
XS_INTERNAL(XS_Lucy_Test_Index_NonMergingIndexManager_new) {
    dXSARGS;
    testlucy_NonMergingIndexManager* arg_self;
    testlucy_NonMergingIndexManager* retval;

    CFISH_UNUSED_VAR(cv);
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    arg_self = (testlucy_NonMergingIndexManager*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_NMIxManager_init(arg_self);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Test_Index_NonMergingIndexManager_recycle);
XS_INTERNAL(XS_Lucy_Test_Index_NonMergingIndexManager_recycle) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[4] = {
        XSBIND_PARAM("reader", 1),
        XSBIND_PARAM("del_writer", 1),
        XSBIND_PARAM("cutoff", 1),
        XSBIND_PARAM("optimize", 0)
    };
    int32_t locations[4];
    SV *sv;
    testlucy_NonMergingIndexManager* arg_self;
    lucy_PolyReader* arg_reader;
    lucy_DeletionsWriter* arg_del_writer;
    int64_t arg_cutoff;
    bool arg_optimize;
    TESTLUCY_NMIxManager_Recycle_t method;
    cfish_Vector* retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self, ...");
    }
    SP -= items;

    /* Locate args on Perl stack. */
    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 4);
    arg_self = (testlucy_NonMergingIndexManager*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_NONMERGINGINDEXMANAGER, NULL);
    sv = ST(locations[0]);
    arg_reader = (lucy_PolyReader*)XSBind_arg_to_cfish(aTHX_ sv, "reader", LUCY_POLYREADER, NULL);
    sv = ST(locations[1]);
    arg_del_writer = (lucy_DeletionsWriter*)XSBind_arg_to_cfish(aTHX_ sv, "del_writer", LUCY_DELETIONSWRITER, NULL);
    sv = ST(locations[2]);
    if (!XSBind_sv_defined(aTHX_ sv)) {
        XSBind_undef_arg_error(aTHX_ "cutoff");
    }
    arg_cutoff = (int64_t)SvNV(sv);
    sv = ST(locations[3]);
    arg_optimize = locations[3] < items && XSBind_sv_defined(aTHX_ sv)
             ? XSBind_sv_true(aTHX_ sv) : false;

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_NONMERGINGINDEXMANAGER, TESTLUCY_NMIxManager_Recycle);
    retval = method(arg_self, arg_reader, arg_del_writer, arg_cutoff, arg_optimize);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    CFISH_DECREF(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Store_MockFileHandle_new);
XS_INTERNAL(XS_Lucy_Store_MockFileHandle_new) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[2] = {
        XSBIND_PARAM("path", 0),
        XSBIND_PARAM("length", 1)
    };
    int32_t locations[2];
    SV *sv;
    testlucy_MockFileHandle* arg_self;
    cfish_String* arg_path;
    int64_t arg_length;
    testlucy_MockFileHandle* retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
    }
    SP -= items;

    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 2);
    sv = ST(locations[0]);
    arg_path = locations[0] < items ? (cfish_String*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "path", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL;
    sv = ST(locations[1]);
    if (!XSBind_sv_defined(aTHX_ sv)) {
        XSBind_undef_arg_error(aTHX_ "length");
    }
    arg_length = (int64_t)SvNV(sv);
    arg_self = (testlucy_MockFileHandle*)XSBind_new_blank_obj(aTHX_ ST(0));

    retval = testlucy_MockFileHandle_init(arg_self, arg_path, arg_length);
    ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
    XSRETURN(1);
}


XS_INTERNAL(XS_Lucy_Store_MockFileHandle_window);
XS_INTERNAL(XS_Lucy_Store_MockFileHandle_window) {
    dXSARGS;
    static const XSBind_ParamSpec param_specs[3] = {
        XSBIND_PARAM("window", 1),
        XSBIND_PARAM("offset", 1),
        XSBIND_PARAM("len", 1)
    };
    int32_t locations[3];
    SV *sv;
    testlucy_MockFileHandle* arg_self;
    lucy_FileWindow* arg_window;
    int64_t arg_offset;
    int64_t arg_len;
    TESTLUCY_MockFileHandle_Window_t method;
    bool retval;

    CFISH_UNUSED_VAR(cv);
    if (items < 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self, ...");
    }
    SP -= items;

    /* Locate args on Perl stack. */
    XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
                       locations, 3);
    arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
    sv = ST(locations[0]);
    arg_window = (lucy_FileWindow*)XSBind_arg_to_cfish(aTHX_ sv, "window", LUCY_FILEWINDOW, NULL);
    sv = ST(locations[1]);
    if (!XSBind_sv_defined(aTHX_ sv)) {
        XSBind_undef_arg_error(aTHX_ "offset");
    }
    arg_offset = (int64_t)SvNV(sv);
    sv = ST(locations[2]);
    if (!XSBind_sv_defined(aTHX_ sv)) {
        XSBind_undef_arg_error(aTHX_ "len");
    }
    arg_len = (int64_t)SvNV(sv);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Window);
    retval = method(arg_self, arg_window, arg_offset, arg_len);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Store_MockFileHandle_release_window);
XS_INTERNAL(XS_Lucy_Store_MockFileHandle_release_window) {
    dXSARGS;
    SV *sv;
    testlucy_MockFileHandle* arg_self;
    lucy_FileWindow* arg_window;
    TESTLUCY_MockFileHandle_Release_Window_t method;
    bool retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, window");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);
    sv = ST(1);
    arg_window = (lucy_FileWindow*)XSBind_arg_to_cfish(aTHX_ sv, "window", LUCY_FILEWINDOW, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Release_Window);
    retval = method(arg_self, arg_window);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Store_MockFileHandle_length);
XS_INTERNAL(XS_Lucy_Store_MockFileHandle_length) {
    dXSARGS;
    testlucy_MockFileHandle* arg_self;
    TESTLUCY_MockFileHandle_Length_t method;
    int64_t retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Length);
    retval = method(arg_self);
    ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Store_MockFileHandle_close);
XS_INTERNAL(XS_Lucy_Store_MockFileHandle_close) {
    dXSARGS;
    testlucy_MockFileHandle* arg_self;
    TESTLUCY_MockFileHandle_Close_t method;
    bool retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_MockFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_MOCKFILEHANDLE, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_MOCKFILEHANDLE, TESTLUCY_MockFileHandle_Close);
    retval = method(arg_self);
    ST(0) = newSViv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_query_string);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_query_string) {
    dXSARGS;
    testlucy_TestQueryParser* arg_self;
    TESTLUCY_TestQP_Get_Query_String_t method;
    cfish_String* retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Query_String);
    retval = method(arg_self);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_tree);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_tree) {
    dXSARGS;
    testlucy_TestQueryParser* arg_self;
    TESTLUCY_TestQP_Get_Tree_t method;
    lucy_Query* retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Tree);
    retval = method(arg_self);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_expanded);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_expanded) {
    dXSARGS;
    testlucy_TestQueryParser* arg_self;
    TESTLUCY_TestQP_Get_Expanded_t method;
    lucy_Query* retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Expanded);
    retval = method(arg_self);
    ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_num_hits);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_get_num_hits) {
    dXSARGS;
    testlucy_TestQueryParser* arg_self;
    TESTLUCY_TestQP_Get_Num_Hits_t method;
    uint32_t retval;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Get_Num_Hits);
    retval = method(arg_self);
    ST(0) = newSVuv(retval);
    sv_2mortal( ST(0) );
    XSRETURN(1);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_DESTROY);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParser_DESTROY) {
    dXSARGS;
    testlucy_TestQueryParser* arg_self;
    TESTLUCY_TestQP_Destroy_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 1) {
        XSBind_invalid_args_error(aTHX_ cv, "self");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParser*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSER, TESTLUCY_TestQP_Destroy);
    method(arg_self);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestStandardTokenizer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestStandardTokenizer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestStandardTokenizer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestStandardTokenizer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestStandardTokenizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSTANDARDTOKENIZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSTANDARDTOKENIZER, TESTLUCY_TestStandardTokenizer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestAnalyzer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestAnalyzer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestAnalyzer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestAnalyzer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTANALYZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTANALYZER, TESTLUCY_TestAnalyzer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestRegexTokenizer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestRegexTokenizer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestRegexTokenizer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestRegexTokenizer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestRegexTokenizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREGEXTOKENIZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTREGEXTOKENIZER, TESTLUCY_TestRegexTokenizer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestNormalizer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestNormalizer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestNormalizer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestNormalizer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestNormalizer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNORMALIZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTNORMALIZER, TESTLUCY_TestNormalizer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStopFilter_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStopFilter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSnowballStopFilter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSnowStop_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSnowballStopFilter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNOWBALLSTOPFILTER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSNOWBALLSTOPFILTER, TESTLUCY_TestSnowStop_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStemmer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestSnowballStemmer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSnowballStemmer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSnowStemmer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSnowballStemmer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNOWBALLSTEMMER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSNOWBALLSTEMMER, TESTLUCY_TestSnowStemmer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestPolyAnalyzer_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestPolyAnalyzer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestPolyAnalyzer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestPolyAnalyzer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestPolyAnalyzer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOLYANALYZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTPOLYANALYZER, TESTLUCY_TestPolyAnalyzer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Analysis_TestCaseFolder_run);
XS_INTERNAL(XS_Lucy_Test_Analysis_TestCaseFolder_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestCaseFolder* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestCaseFolder_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestCaseFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCASEFOLDER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTCASEFOLDER, TESTLUCY_TestCaseFolder_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestPriorityQueue_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestPriorityQueue_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestPriorityQueue* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestPriQ_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestPriorityQueue*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPRIORITYQUEUE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTPRIORITYQUEUE, TESTLUCY_TestPriQ_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestIndexFileNames_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestIndexFileNames_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestIndexFileNames* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestIxFileNames_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestIndexFileNames*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINDEXFILENAMES, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTINDEXFILENAMES, TESTLUCY_TestIxFileNames_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestSortExternal_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestSortExternal_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSortExternal* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSortExternal_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSortExternal*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTEXTERNAL, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTEXTERNAL, TESTLUCY_TestSortExternal_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestMemoryPool_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestMemoryPool_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestMemoryPool* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestMemPool_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestMemoryPool*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTMEMORYPOOL, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTMEMORYPOOL, TESTLUCY_TestMemPool_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestStringHelper_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestStringHelper_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestStringHelper* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestStrHelp_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestStringHelper*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSTRINGHELPER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSTRINGHELPER, TESTLUCY_TestStrHelp_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestNumberUtils_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestNumberUtils_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestNumberUtils* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestNumUtil_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestNumberUtils*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNUMBERUTILS, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTNUMBERUTILS, TESTLUCY_TestNumUtil_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestFreezer_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestFreezer_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFreezer* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFreezer_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFreezer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFREEZER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFREEZER, TESTLUCY_TestFreezer_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Util_TestJson_run);
XS_INTERNAL(XS_Lucy_Test_Util_TestJson_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestJson* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestJson_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestJson*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTJSON, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTJSON, TESTLUCY_TestJson_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Highlight_TestHighlighter_run);
XS_INTERNAL(XS_Lucy_Test_Highlight_TestHighlighter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestHighlighter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestHighlighter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestHighlighter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHIGHLIGHTER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTHIGHLIGHTER, TESTLUCY_TestHighlighter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Highlight_TestHeatMap_run);
XS_INTERNAL(XS_Lucy_Test_Highlight_TestHeatMap_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestHeatMap* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestHeatMap_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestHeatMap*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHEATMAP, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTHEATMAP, TESTLUCY_TestHeatMap_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestFullTextType_run);
XS_INTERNAL(XS_Lucy_Test_Plan_TestFullTextType_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFullTextType* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFullTextType_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFullTextType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFULLTEXTTYPE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFULLTEXTTYPE, TESTLUCY_TestFullTextType_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldMisc_run);
XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldMisc_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFieldMisc* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFieldMisc_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFieldMisc*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFIELDMISC, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFIELDMISC, TESTLUCY_TestFieldMisc_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldType_run);
XS_INTERNAL(XS_Lucy_Test_Plan_TestFieldType_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFieldType* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFType_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFieldType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFIELDTYPE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFIELDTYPE, TESTLUCY_TestFType_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestNumericType_run);
XS_INTERNAL(XS_Lucy_Test_Plan_TestNumericType_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestNumericType* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestNumericType_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestNumericType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNUMERICTYPE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTNUMERICTYPE, TESTLUCY_TestNumericType_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Plan_TestBlobType_run);
XS_INTERNAL(XS_Lucy_Test_Plan_TestBlobType_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestBlobType* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestBlobType_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestBlobType*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBLOBTYPE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTBLOBTYPE, TESTLUCY_TestBlobType_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestLeafQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestLeafQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestLeafQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestLeafQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestLeafQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTLEAFQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTLEAFQUERY, TESTLUCY_TestLeafQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestNOTQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestNOTQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestNOTQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestNOTQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestNOTQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNOTQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTNOTQUERY, TESTLUCY_TestNOTQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestRangeQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestRangeQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestRangeQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestRangeQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestRangeQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRANGEQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTRANGEQUERY, TESTLUCY_TestRangeQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestANDQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestANDQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestANDQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestANDQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestANDQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTANDQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTANDQUERY, TESTLUCY_TestANDQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestORQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestORQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestORQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestORQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestORQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTORQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTORQUERY, TESTLUCY_TestORQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserLogic_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserLogic_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestQueryParserLogic* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestQPLogic_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParserLogic*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSERLOGIC, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSERLOGIC, TESTLUCY_TestQPLogic_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestReqOptQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestReqOptQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestReqOptQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestReqOptQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestReqOptQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTREQOPTQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTREQOPTQUERY, TESTLUCY_TestReqOptQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestPhraseQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestPhraseQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestPhraseQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestPhraseQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestPhraseQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPHRASEQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTPHRASEQUERY, TESTLUCY_TestPhraseQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserSyntax_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestQueryParserSyntax_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestQueryParserSyntax* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestQPSyntax_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestQueryParserSyntax*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTQUERYPARSERSYNTAX, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTQUERYPARSERSYNTAX, TESTLUCY_TestQPSyntax_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestSeriesMatcher_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestSeriesMatcher_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSeriesMatcher* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSeriesMatcher_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSeriesMatcher*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSERIESMATCHER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSERIESMATCHER, TESTLUCY_TestSeriesMatcher_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestMatchAllQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestMatchAllQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestMatchAllQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestMatchAllQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestMatchAllQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTMATCHALLQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTMATCHALLQUERY, TESTLUCY_TestMatchAllQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestTermQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestTermQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestTermQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestTermQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestTermQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTTERMQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTTERMQUERY, TESTLUCY_TestTermQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestNoMatchQuery_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestNoMatchQuery_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestNoMatchQuery* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestNoMatchQuery_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestNoMatchQuery*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTNOMATCHQUERY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTNOMATCHQUERY, TESTLUCY_TestNoMatchQuery_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestSortSpec_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestSortSpec_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSortSpec* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSortSpec_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSortSpec*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTSPEC, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTSPEC, TESTLUCY_TestSortSpec_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Search_TestSpan_run);
XS_INTERNAL(XS_Lucy_Test_Search_TestSpan_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSpan* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSpan_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSpan*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSPAN, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSPAN, TESTLUCY_TestSpan_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Object_TestBitVector_run);
XS_INTERNAL(XS_Lucy_Test_Object_TestBitVector_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestBitVector* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestBitVector_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestBitVector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBITVECTOR, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTBITVECTOR, TESTLUCY_TestBitVector_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Object_TestI32Array_run);
XS_INTERNAL(XS_Lucy_Test_Object_TestI32Array_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestI32Array* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestI32Arr_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestI32Array*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTI32ARRAY, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTI32ARRAY, TESTLUCY_TestI32Arr_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_TestBatchSchema_run);
XS_INTERNAL(XS_Lucy_Test_TestBatchSchema_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestBatchSchema* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestBatchSchema_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestBatchSchema*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTBATCHSCHEMA, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTBATCHSCHEMA, TESTLUCY_TestBatchSchema_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestSegWriter_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestSegWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSegWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSegWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSegWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSEGWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSEGWRITER, TESTLUCY_TestSegWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestSnapshot_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestSnapshot_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSnapshot* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSnapshot_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSnapshot*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSNAPSHOT, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSNAPSHOT, TESTLUCY_TestSnapshot_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestSortWriter_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestSortWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSortWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSortWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSortWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSORTWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSORTWRITER, TESTLUCY_TestSortWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestSegment_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestSegment_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSegment* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSeg_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSegment*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSEGMENT, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSEGMENT, TESTLUCY_TestSeg_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestDocWriter_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestDocWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestDocWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestDocWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestDocWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTDOCWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTDOCWRITER, TESTLUCY_TestDocWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestTermInfo_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestTermInfo_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestTermInfo* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestTermInfo_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestTermInfo*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTTERMINFO, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTTERMINFO, TESTLUCY_TestTermInfo_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestPostingListWriter_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestPostingListWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestPostingListWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestPListWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestPostingListWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOSTINGLISTWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTPOSTINGLISTWRITER, TESTLUCY_TestPListWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestIndexManager_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestIndexManager_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestIndexManager* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestIxManager_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestIndexManager*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINDEXMANAGER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTINDEXMANAGER, TESTLUCY_TestIxManager_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestPolyReader_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestPolyReader_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestPolyReader* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestPolyReader_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestPolyReader*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTPOLYREADER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTPOLYREADER, TESTLUCY_TestPolyReader_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Index_TestHighlightWriter_run);
XS_INTERNAL(XS_Lucy_Test_Index_TestHighlightWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestHighlightWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestHLWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestHighlightWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTHIGHLIGHTWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTHIGHLIGHTWRITER, TESTLUCY_TestHLWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_TestSimple_run);
XS_INTERNAL(XS_Lucy_Test_TestSimple_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestSimple* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestSimple_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestSimple*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTSIMPLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTSIMPLE, TESTLUCY_TestSimple_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestFSDirHandle_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestFSDirHandle_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFSDirHandle* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFSDH_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFSDirHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSDIRHANDLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFSDIRHANDLE, TESTLUCY_TestFSDH_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestInStream_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestInStream_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestInStream* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestInStream_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestInStream*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTINSTREAM, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTINSTREAM, TESTLUCY_TestInStream_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestFSFileHandle_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestFSFileHandle_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFSFileHandle* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFSFH_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFSFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSFILEHANDLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFSFILEHANDLE, TESTLUCY_TestFSFH_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestIOChunks_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestIOChunks_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestIOChunks* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestIOChunks_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestIOChunks*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTIOCHUNKS, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTIOCHUNKS, TESTLUCY_TestIOChunks_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestFSFolder_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestFSFolder_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFSFolder* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFSFolder_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFSFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFSFOLDER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFSFOLDER, TESTLUCY_TestFSFolder_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFileHandle_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFileHandle_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestRAMFileHandle* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestRAMFH_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestRAMFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMFILEHANDLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMFILEHANDLE, TESTLUCY_TestRAMFH_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestIOPrimitives_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestIOPrimitives_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestIOPrimitives* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestIOPrimitives_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestIOPrimitives*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTIOPRIMITIVES, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTIOPRIMITIVES, TESTLUCY_TestIOPrimitives_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileWriter_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileWriter_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestCompoundFileWriter* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestCFWriter_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestCompoundFileWriter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCOMPOUNDFILEWRITER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTCOMPOUNDFILEWRITER, TESTLUCY_TestCFWriter_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestRAMDirHandle_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestRAMDirHandle_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestRAMDirHandle* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestRAMDH_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestRAMDirHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMDIRHANDLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMDIRHANDLE, TESTLUCY_TestRAMDH_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFolder_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestRAMFolder_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestRAMFolder* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestRAMFolder_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestRAMFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTRAMFOLDER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTRAMFOLDER, TESTLUCY_TestRAMFolder_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileReader_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestCompoundFileReader_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestCompoundFileReader* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestCFReader_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestCompoundFileReader*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTCOMPOUNDFILEREADER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTCOMPOUNDFILEREADER, TESTLUCY_TestCFReader_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestFileHandle_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestFileHandle_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFileHandle* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFH_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFileHandle*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFILEHANDLE, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFILEHANDLE, TESTLUCY_TestFH_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}

XS_INTERNAL(XS_Lucy_Test_Store_TestFolder_run);
XS_INTERNAL(XS_Lucy_Test_Store_TestFolder_run) {
    dXSARGS;
    SV *sv;
    testlucy_TestFolder* arg_self;
    cfish_TestBatchRunner* arg_runner;
    TESTLUCY_TestFolder_Run_t method;

    CFISH_UNUSED_VAR(cv);
    SP -= items;
    if (items != 2) {
        XSBind_invalid_args_error(aTHX_ cv, "self, runner");
    }

    /* Extract vars from Perl stack. */
    arg_self = (testlucy_TestFolder*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), TESTLUCY_TESTFOLDER, NULL);
    sv = ST(1);
    arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);

    /* Execute */
    method = CFISH_METHOD_PTR(TESTLUCY_TESTFOLDER, TESTLUCY_TestFolder_Run);
    method(arg_self, arg_runner);
    XSRETURN(0);
}


#line 2366 "lib/Lucy/Test.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 2510 "lib/Lucy/Test.c"
#include "Clownfish/TestHarness/TestFormatter.h"
#include "Clownfish/TestHarness/TestSuite.h"

XS_EUPXS(XS_Lucy__Test_run_tests); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Lucy__Test_run_tests)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "package");
    {
	char *	package = (char *)SvPV_nolen(ST(0))
;
	bool	RETVAL;
	dXSTARG;
#line 2544 "lib/Lucy/Test.xs"
    cfish_String *class_name = cfish_Str_newf("%s", package);
    cfish_TestFormatter *formatter
        = (cfish_TestFormatter*)cfish_TestFormatterTAP_new();
    cfish_TestSuite *suite = testlucy_Test_create_test_suite();
    bool result = CFISH_TestSuite_Run_Batch(suite, class_name, formatter);
    CFISH_DECREF(class_name);
    CFISH_DECREF(formatter);
    CFISH_DECREF(suite);

    RETVAL = result;
#line 2536 "lib/Lucy/Test.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Lucy__Test); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Lucy__Test)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if PERL_VERSION_LE(5, 8, 999) /* PERL_VERSION_LT is 5.33+ */
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

        newXS_deffile("Lucy::Test::run_tests", XS_Lucy__Test_run_tests);

    /* Initialisation Section */

#line 2359 "lib/Lucy/Test.xs"
{
    static const cfish_XSBind_ClassSpec class_specs[] = {
        { "Lucy::Test::Analysis::DummyAnalyzer", "Lucy::Analysis::Analyzer", 2 },
        { "Lucy::Test::Util::NumPriorityQueue", "Lucy::Util::PriorityQueue", 1 },
        { "Lucy::Test::Search::TestReverseType", "Lucy::Plan::Int32Type", 2 },
        { "Lucy::Test::Plan::DummyFieldType", "Lucy::Plan::FieldType", 0 },
        { "Lucy::Test::TestSchema", "Lucy::Plan::Schema", 2 },
        { "Lucy::Test::Plan::TestArchitecture", "Lucy::Plan::Architecture", 3 },
        { "Lucy::Test::Index::NonMergingIndexManager", "Lucy::Index::IndexManager", 2 },
        { "Lucy::Store::MockFileHandle", "Lucy::Store::FileHandle", 5 },
        { "Lucy::Test::Search::TestQueryParser", "Clownfish::Obj", 5 },
        { "Lucy::Test::Analysis::TestStandardTokenizer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestAnalyzer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestRegexTokenizer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestNormalizer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestSnowballStopFilter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestSnowballStemmer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestPolyAnalyzer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Analysis::TestCaseFolder", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestPriorityQueue", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestIndexFileNames", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestSortExternal", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestMemoryPool", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestStringHelper", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestNumberUtils", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestFreezer", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Util::TestJson", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Highlight::TestHighlighter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Highlight::TestHeatMap", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Plan::TestFullTextType", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Plan::TestFieldMisc", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Plan::TestFieldType", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Plan::TestNumericType", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Plan::TestBlobType", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestLeafQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestNOTQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestRangeQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestANDQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestORQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestQueryParserLogic", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestReqOptQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestPhraseQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestQueryParserSyntax", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestSeriesMatcher", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestMatchAllQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestTermQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestNoMatchQuery", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestSortSpec", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Search::TestSpan", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Object::TestBitVector", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Object::TestI32Array", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::TestBatchSchema", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestSegWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestSnapshot", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestSortWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestSegment", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestDocWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestTermInfo", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestPostingListWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestIndexManager", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestPolyReader", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Index::TestHighlightWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::TestSimple", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestFSDirHandle", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestInStream", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestFSFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestIOChunks", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestFSFolder", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestRAMFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestIOPrimitives", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestCompoundFileWriter", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestRAMDirHandle", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestRAMFolder", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestCompoundFileReader", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestFileHandle", "Clownfish::TestHarness::TestBatch", 1 },
        { "Lucy::Test::Store::TestFolder", "Clownfish::TestHarness::TestBatch", 1 }
    };
    static const cfish_XSBind_XSubSpec xsub_specs[] = {
        { "new", XS_Lucy_Test_Analysis_DummyAnalyzer_new },
        { "transform", XS_Lucy_Test_Analysis_DummyAnalyzer_transform },
        { "less_than", XS_Lucy_Test_Util_NumPriorityQueue_less_than },
        { "new", XS_Lucy_Test_Search_TestReverseType_new },
        { "compare_values", XS_Lucy_Test_Search_TestReverseType_compare_values },
        { "new", XS_Lucy_Test_TestSchema_new },
        { "architecture", XS_Lucy_Test_TestSchema_architecture },
        { "new", XS_Lucy_Test_Plan_TestArchitecture_new },
        { "index_interval", XS_Lucy_Test_Plan_TestArchitecture_index_interval },
        { "skip_interval", XS_Lucy_Test_Plan_TestArchitecture_skip_interval },
        { "new", XS_Lucy_Test_Index_NonMergingIndexManager_new },
        { "recycle", XS_Lucy_Test_Index_NonMergingIndexManager_recycle },
        { "new", XS_Lucy_Store_MockFileHandle_new },
        { "window", XS_Lucy_Store_MockFileHandle_window },
        { "release_window", XS_Lucy_Store_MockFileHandle_release_window },
        { "length", XS_Lucy_Store_MockFileHandle_length },
        { "close", XS_Lucy_Store_MockFileHandle_close },
        { "get_query_string", XS_Lucy_Test_Search_TestQueryParser_get_query_string },
        { "get_tree", XS_Lucy_Test_Search_TestQueryParser_get_tree },
        { "get_expanded", XS_Lucy_Test_Search_TestQueryParser_get_expanded },
        { "get_num_hits", XS_Lucy_Test_Search_TestQueryParser_get_num_hits },
        { "DESTROY", XS_Lucy_Test_Search_TestQueryParser_DESTROY },
        { "run", XS_Lucy_Test_Analysis_TestStandardTokenizer_run },
        { "run", XS_Lucy_Test_Analysis_TestAnalyzer_run },
        { "run", XS_Lucy_Test_Analysis_TestRegexTokenizer_run },
        { "run", XS_Lucy_Test_Analysis_TestNormalizer_run },
        { "run", XS_Lucy_Test_Analysis_TestSnowballStopFilter_run },
        { "run", XS_Lucy_Test_Analysis_TestSnowballStemmer_run },
        { "run", XS_Lucy_Test_Analysis_TestPolyAnalyzer_run },
        { "run", XS_Lucy_Test_Analysis_TestCaseFolder_run },
        { "run", XS_Lucy_Test_Util_TestPriorityQueue_run },
        { "run", XS_Lucy_Test_Util_TestIndexFileNames_run },
        { "run", XS_Lucy_Test_Util_TestSortExternal_run },
        { "run", XS_Lucy_Test_Util_TestMemoryPool_run },
        { "run", XS_Lucy_Test_Util_TestStringHelper_run },
        { "run", XS_Lucy_Test_Util_TestNumberUtils_run },
        { "run", XS_Lucy_Test_Util_TestFreezer_run },
        { "run", XS_Lucy_Test_Util_TestJson_run },
        { "run", XS_Lucy_Test_Highlight_TestHighlighter_run },
        { "run", XS_Lucy_Test_Highlight_TestHeatMap_run },
        { "run", XS_Lucy_Test_Plan_TestFullTextType_run },
        { "run", XS_Lucy_Test_Plan_TestFieldMisc_run },
        { "run", XS_Lucy_Test_Plan_TestFieldType_run },
        { "run", XS_Lucy_Test_Plan_TestNumericType_run },
        { "run", XS_Lucy_Test_Plan_TestBlobType_run },
        { "run", XS_Lucy_Test_Search_TestLeafQuery_run },
        { "run", XS_Lucy_Test_Search_TestNOTQuery_run },
        { "run", XS_Lucy_Test_Search_TestRangeQuery_run },
        { "run", XS_Lucy_Test_Search_TestANDQuery_run },
        { "run", XS_Lucy_Test_Search_TestORQuery_run },
        { "run", XS_Lucy_Test_Search_TestQueryParserLogic_run },
        { "run", XS_Lucy_Test_Search_TestReqOptQuery_run },
        { "run", XS_Lucy_Test_Search_TestPhraseQuery_run },
        { "run", XS_Lucy_Test_Search_TestQueryParserSyntax_run },
        { "run", XS_Lucy_Test_Search_TestSeriesMatcher_run },
        { "run", XS_Lucy_Test_Search_TestMatchAllQuery_run },
        { "run", XS_Lucy_Test_Search_TestTermQuery_run },
        { "run", XS_Lucy_Test_Search_TestNoMatchQuery_run },
        { "run", XS_Lucy_Test_Search_TestSortSpec_run },
        { "run", XS_Lucy_Test_Search_TestSpan_run },
        { "run", XS_Lucy_Test_Object_TestBitVector_run },
        { "run", XS_Lucy_Test_Object_TestI32Array_run },
        { "run", XS_Lucy_Test_TestBatchSchema_run },
        { "run", XS_Lucy_Test_Index_TestSegWriter_run },
        { "run", XS_Lucy_Test_Index_TestSnapshot_run },
        { "run", XS_Lucy_Test_Index_TestSortWriter_run },
        { "run", XS_Lucy_Test_Index_TestSegment_run },
        { "run", XS_Lucy_Test_Index_TestDocWriter_run },
        { "run", XS_Lucy_Test_Index_TestTermInfo_run },
        { "run", XS_Lucy_Test_Index_TestPostingListWriter_run },
        { "run", XS_Lucy_Test_Index_TestIndexManager_run },
        { "run", XS_Lucy_Test_Index_TestPolyReader_run },
        { "run", XS_Lucy_Test_Index_TestHighlightWriter_run },
        { "run", XS_Lucy_Test_TestSimple_run },
        { "run", XS_Lucy_Test_Store_TestFSDirHandle_run },
        { "run", XS_Lucy_Test_Store_TestInStream_run },
        { "run", XS_Lucy_Test_Store_TestFSFileHandle_run },
        { "run", XS_Lucy_Test_Store_TestIOChunks_run },
        { "run", XS_Lucy_Test_Store_TestFSFolder_run },
        { "run", XS_Lucy_Test_Store_TestRAMFileHandle_run },
        { "run", XS_Lucy_Test_Store_TestIOPrimitives_run },
        { "run", XS_Lucy_Test_Store_TestCompoundFileWriter_run },
        { "run", XS_Lucy_Test_Store_TestRAMDirHandle_run },
        { "run", XS_Lucy_Test_Store_TestRAMFolder_run },
        { "run", XS_Lucy_Test_Store_TestCompoundFileReader_run },
        { "run", XS_Lucy_Test_Store_TestFileHandle_run },
        { "run", XS_Lucy_Test_Store_TestFolder_run }
    };
    size_t num_classes
        = sizeof(class_specs) / sizeof(class_specs[0]);
    const char* file = __FILE__;

    testlucy_bootstrap_perl();

    cfish_XSBind_bootstrap(aTHX_ num_classes, class_specs,
                           xsub_specs, file);
}

#line 2752 "lib/Lucy/Test.c"

    /* End of Initialisation Section */

#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

