import junit.framework.*;
import ISISJAVA.*;


public class TestISISAPI extends TestCase {
    private ISISAPI iSISAPI = null;

    public TestISISAPI(String name) {
        super(name);
    }

    protected void setUp() throws Exception {
        super.setUp();
        iSISAPI = new ISISAPI();
    }

    protected void tearDown() throws Exception {
        iSISAPI = null;
        super.tearDown();
    }

    public void testIsisAppAcTab() {
        int handle = 0;
        String actab = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppAcTab(handle, actab);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppDebug() {
        int apphandle = 0;
        int debugflag = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppDebug(apphandle, debugflag);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppDelete() {
        int apphandle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppDelete(apphandle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppLogFile() {
        int apphandle = 0;
        String filename = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppLogFile(apphandle, filename);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppNew() {
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppNew();
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppParGet() {
        int apphandle = 0;
        String ipar = "";
        String[] opar = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppParGet(apphandle, ipar, opar, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppParSet() {
        int apphandle = 0;
        String apparea = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppParSet(apphandle, apparea);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisAppUcTab() {
        int apphandle = 0;
        String uctab = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisAppUcTab(apphandle, uctab);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisDllVersion() {
        float expectedReturn = 0.0F;
        float actualReturn = iSISAPI.IsisDllVersion();
        System.out.println("Version of DLL - " + actualReturn);
        //assertEquals("return value", expectedReturn, actualReturn, Float.MIN_VALUE);
        /**@todo fill in the test code*/
    }

    public void testIsisLnkIfLoad() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisLnkIfLoad(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisLnkIfLoadEx() {
        int handle = 0;
        int reset = 0;
        int posts = 0;
        int balan = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisLnkIfLoadEx(handle, reset, posts, balan);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisLnkSort() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisLnkSort(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecControlMap() {
        int handle = 0;
        IsisRecControl ctrl = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecControlMap(handle, ctrl);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecCopy() {
        int handle_from = 0;
        int index_from = 0;
        int handle_to = 0;
        int index_to = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecCopy(handle_from, index_from, handle_to, index_to);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecDirMap() {
        int handle = 0;
        int index = 0;
        int firstpos = 0;
        int lastpos = 0;
        IsisRecDir[] dir = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecDirMap(handle, index, firstpos, lastpos, dir);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecDummy() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecDummy(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecDump() {
        int handle = 0;
        int index = 0;
        String[] dump = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecDump(handle, index, dump, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecField() {
        int handle = 0;
        int index = 0;
        int tag = 0;
        int occ = 0;
        String[] field_area = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecField(handle, index, tag, occ, field_area, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecFieldN() {
        int handle = 0;
        int index = 0;
        int pos = 0;
        String[] field_area = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecFieldN(handle, index, pos, field_area, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecFieldOcc() {
        int handle = 0;
        int index = 0;
        int tag = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecFieldOcc(handle, index, tag);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecFieldUpdate() {
        int handle = 0;
        int index = 0;
        String fldupd = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecFieldUpdate(handle, index, fldupd);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecFormat() {
        int handle = 0;
        int index = 0;
        String[] farea = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecFormat(handle, index, farea, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecFormatEx() {
        int handle = 0;
        int index = 0;
        int linesize = 0;
        String[] farea = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecFormatEx(handle, index, linesize, farea, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecIfUpdate() {
        int handle = 0;
        int mfn = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecIfUpdate(handle, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecIfUpdateEx() {
        int handle = 0;
        int beginmfn = 0;
        int endmfn = 0;
        int keeppending = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecIfUpdateEx(handle, beginmfn, endmfn, keeppending);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecIsoRead() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecIsoRead(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecIsoWrite() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecIsoWrite(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecLeaderMap() {
        int handle = 0;
        int index = 0;
        IsisRecLeader leader = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecLeaderMap(handle, index, leader);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecLnk() {
        int handle = 0;
        int beginmfn = 0;
        int endmfn = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecLnk(handle, beginmfn, endmfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecLockRecall() {
        int handle = 0;
        int index = 0;
        int mfn = 0;
        int tag = 0;
        String password = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecLockRecall(handle, index, mfn, tag, password);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecMerge() {
        int handle_from = 0;
        int index_from = 0;
        int handle_to = 0;
        int index_to = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecMerge(handle_from, index_from, handle_to, index_to);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecMfn() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecMfn(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecMfnChange() {
        int handle = 0;
        int index = 0;
        int mfn = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecMfnChange(handle, index, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecNew() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecNew(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecNewLock() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecNewLock(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecNvf() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecNvf(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecRead() {
        int handle = 0;
        int index = 0;
        int mfn = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecRead(handle, index, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecReadLock() {
        int handle = 0;
        int index = 0;
        int mfn = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecReadLock(handle, index, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecShelfSize() {
        int handle = 0;
        int index = 0;
        int mem = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecShelfSize(handle, index, mem);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecSubField() {
        int handle = 0;
        int index = 0;
        int tag = 0;
        int fldocc = 0;
        String subfield = "";
        String[] subfield_area = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecSubField(handle, index, tag, fldocc, subfield, subfield_area, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecSubFieldEx() {
        int handle = 0;
        int index = 0;
        int tag = 0;
        int fldocc = 0;
        String subfield = "";
        int subfldocc = 0;
        String[] subfield_area = null;
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecSubFieldEx(handle, index, tag, fldocc, subfield, subfldocc, subfield_area, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecUndelete() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecUndelete(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecUnlock() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecUnlock(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecUnlockForce() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecUnlockForce(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecUpdate() {
        int handle = 0;
        int index = 0;
        String sparser = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecUpdate(handle, index, sparser);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecWrite() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecWrite(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecWriteLock() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecWriteLock(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisRecWriteUnlock() {
        int handle = 0;
        int index = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisRecWriteUnlock(handle, index);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaDb() {
        int handle = 0;
        String dbname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaDb(handle, dbname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaDelete() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaDelete(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaFdt() {
        int handle = 0;
        String fdtname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaFdt(handle, fdtname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaFst() {
        int handle = 0;
        String fstname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaFst(handle, fstname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaGf() {
        int handle = 0;
        String gizname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaGf(handle, gizname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaHeaderMap() {
        int handle = 0;
        IsisSpaHeader header = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaHeaderMap(handle, header);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIf() {
        int handle = 0;
        String ifname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIf(handle, ifname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIfCreate() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIfCreate(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIsoDelim() {
        int handle = 0;
        String recdelim = "";
        String fielddelim = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIsoDelim(handle, recdelim, fielddelim);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIsoIn() {
        int handle = 0;
        String filename = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIsoIn(handle, filename);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIsoOut() {
        int handle = 0;
        String filename = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIsoOut(handle, filename);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaIsoOutCreate() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaIsoOutCreate(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaMf() {
        int handle = 0;
        String mfname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaMf(handle, mfname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaMfCreate() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaMfCreate(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaMfUnlockForce() {
        int handle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaMfUnlockForce(handle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaName() {
        int handle = 0;
        String sname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaName(handle, sname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaNew() {
        int apphandle = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaNew(apphandle);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaPft() {
        int handle = 0;
        String format = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaPft(handle, format);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaRecDelim() {
        int handle = 0;
        String begindelim = "";
        String enddelim = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaRecDelim(handle, begindelim, enddelim);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaRecShelves() {
        int handle = 0;
        int max_mst = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaRecShelves(handle, max_mst);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaStw() {
        int handle = 0;
        String stwname = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaStw(handle, stwname);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSpaTrmShelves() {
        int handle = 0;
        int max_trm = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSpaTrmShelves(handle, max_trm);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcHeaderMap() {
        int apphandle = 0;
        int tsfnum = 0;
        int searchnum = 0;
        IsisSrcHeader header = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcHeaderMap(apphandle, tsfnum, searchnum, header);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcLogFileFlush() {
        int apphandle = 0;
        int tsfnum = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcLogFileFlush(apphandle, tsfnum);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcLogFileSave() {
        int apphandle = 0;
        int tsfnum = 0;
        String filename = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcLogFileSave(apphandle, tsfnum, filename);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcLogFileUse() {
        int apphandle = 0;
        int tsfnum = 0;
        String filename = "";
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcLogFileUse(apphandle, tsfnum, filename);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcMfnMap() {
        int apphandle = 0;
        int tsfnum = 0;
        int searchnum = 0;
        int firstpos = 0;
        int lastpos = 0;
        IsisSrcMfn[] mfn = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcMfnMap(apphandle, tsfnum, searchnum, firstpos, lastpos, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcRegExpMap() {
        int handle = 0;
        String expr = "";
        int mfnb = 0;
        int mfne = 0;
        String areap = "";
        int areasize = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcRegExpMap(handle, expr, mfnb, mfne, areap, areasize);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcSearch() {
        int handle = 0;
        int tsfnum = 0;
        String express = "";
        IsisSrcHeader header = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcSearch(handle, tsfnum, express, header);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisSrcSearchEx() {
        int handle = 0;
        int tsfnum = 0;
        String itable = "";
        String express = "";
        IsisSrcHeader header = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisSrcSearchEx(handle, tsfnum, itable, express, header);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmMfnMap() {
        int handle = 0;
        int index_trm = 0;
        int firstpos = 0;
        int lastpos = 0;
        IsisTrmMfn[] mfn = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmMfnMap(handle, index_trm, firstpos, lastpos, mfn);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmPostingMap() {
        int handle = 0;
        int index_trm = 0;
        int firstpos = 0;
        int lastpos = 0;
        IsisTrmPosting[] posting = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmPostingMap(handle, index_trm, firstpos, lastpos, posting);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmReadMap() {
        int handle = 0;
        int index_trm = 0;
        IsisTrmRead key = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmReadMap(handle, index_trm, key);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmReadNext() {
        int handle = 0;
        int index_trm = 0;
        IsisTrmRead key = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmReadNext(handle, index_trm, key);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmReadPrevious() {
        int handle = 0;
        int index_trm = 0;
        String prefix = "";
        IsisTrmRead key = null;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmReadPrevious(handle, index_trm, prefix, key);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testIsisTrmShelfSize() {
        int handle = 0;
        int index_trm = 0;
        int mem = 0;
        int expectedReturn = 0;
        //int actualReturn = iSISAPI.IsisTrmShelfSize(handle, index_trm, mem);
        //assertEquals("return value", expectedReturn, actualReturn);
        /**@todo fill in the test code*/
    }

    public void testISISAPI() {
        iSISAPI = new ISISAPI();
        /**@todo fill in the test code*/
    }

}