Fix MEX files link. 20/15920/7
Vincent COUVERT [Fri, 6 Feb 2015 15:22:30 +0000 (16:22 +0100)]
Update tests to use assert_* functions.
Regenerate refs (contained many useless blank lines).

To test: test_run("mexlib", ["mexCall" "mexEvalString" "mexPrintf" "mexPutFull" "mexPutVariable" "mexWarnMsgTxt" "mxAddField" "mxArrayToString" "mxCalcSingleSubscript" "mxCheckTypes" "mxCreateCell" "mxCreateCharMatrixFromStrings" "mxCreateDouble" ...
   "mxCreateLogicalArray" "mxCreateLogicalMatrix" "mxCreateLogicalScalar" "mxCreateNumericArray" "mxCreateString" "mxCreateStruct" "mxDuplicateArray" "mxGetChars" "mxGetClassID" "mxGetClassName" "mxGetDimensions" "mxGetElementSize" "mxGetEps" ...
   "mxGetField" "mxGetFieldByNumber" "mxGetFieldNameByNumber" "mxGetInf" "mxGetLogicals" "mxGetNaN" "mxGetNumberOfDimensions" "mxGetNumberOfElements" "mxGetNumberOfFields" "mxGetScalar" "mxGetSetData" "mxGetSetImagData" "mxGetSetMN" "mxGetSetPri" "mxGetString"  ...
   "mxIsClass" "mxIsComplex" "mxIsEmpty" "mxIsFinite" "mxIsInf" "mxIsLogicalScalar" "mxIsNaN" "mxMalloc" "mxSetCell" "mxSetDimensions" "mxSetField" "mxSetFieldByNumber" "bug_614"])

Change-Id: I83453e01b3d0487ee324796fc6db90dce339b2ed

113 files changed:
scilab/modules/ast/includes/types/addfunction.h
scilab/modules/ast/includes/types/c_gateway_prototype.h
scilab/modules/ast/src/cpp/types/addfunction.cpp
scilab/modules/dynamic_link/macros/ilib_gen_gateway.sci
scilab/modules/dynamic_link/macros/windows/dlwGetScilabLibraries.sci
scilab/modules/mexlib/tests/nonreg_tests/bug_614.dia.ref
scilab/modules/mexlib/tests/nonreg_tests/bug_614.tst
scilab/modules/mexlib/tests/unit_tests/mexCall.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexCall.tst
scilab/modules/mexlib/tests/unit_tests/mexEvalString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexEvalString.tst
scilab/modules/mexlib/tests/unit_tests/mexPrintf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexPrintf.tst
scilab/modules/mexlib/tests/unit_tests/mexPutFull.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexPutFull.tst
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexPutVariable.tst
scilab/modules/mexlib/tests/unit_tests/mexWarnMsgTxt.dia.ref
scilab/modules/mexlib/tests/unit_tests/mexWarnMsgTxt.tst
scilab/modules/mexlib/tests/unit_tests/mxAddField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxAddField.tst
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxArrayToString.tst
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCalcSingleSubscript.tst
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCheckTypes.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateCell.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateCharMatrixFromStrings.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateCharMatrixFromStrings.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateDouble.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalArray.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalMatrix.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateLogicalScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateNumericArray.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateString.tst
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxCreateStruct.tst
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxDuplicateArray.tst
scilab/modules/mexlib/tests/unit_tests/mxGetChars.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetChars.tst
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetClassID.tst
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetClassName.tst
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxGetElementSize.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetElementSize.tst
scilab/modules/mexlib/tests/unit_tests/mxGetEps.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetEps.tst
scilab/modules/mexlib/tests/unit_tests/mxGetField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetField.tst
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetFieldByNumber.tst
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetFieldNameByNumber.tst
scilab/modules/mexlib/tests/unit_tests/mxGetInf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetInf.tst
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetLogicals.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNaN.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfElements.tst
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetNumberOfFields.tst
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetData.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetImagData.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetImagData.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetMN.tst
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetSetPri.tst
scilab/modules/mexlib/tests/unit_tests/mxGetString.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxGetString.tst
scilab/modules/mexlib/tests/unit_tests/mxIsClass.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsClass.tst
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsComplex.tst
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsEmpty.tst
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsFinite.tst
scilab/modules/mexlib/tests/unit_tests/mxIsInf.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsInf.tst
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsLogicalScalar.tst
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxIsNaN.tst
scilab/modules/mexlib/tests/unit_tests/mxMalloc.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxMalloc.tst
scilab/modules/mexlib/tests/unit_tests/mxSetCell.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetCell.tst
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetDimensions.tst
scilab/modules/mexlib/tests/unit_tests/mxSetField.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetField.tst
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.dia.ref
scilab/modules/mexlib/tests/unit_tests/mxSetFieldByNumber.tst

index 71cd74b..66bd6b3 100644 (file)
@@ -17,5 +17,6 @@
 #include "dynlib_ast.h"
 
 EXTERN_AST void addCFunction(wchar_t* _wstName, OLDGW_FUNC _pFunc, wchar_t* _wstModule);
+EXTERN_AST void addMexFunction(wchar_t* _wstName, MEXGW_FUNC _pFunc, wchar_t* _wstModule);
 
 #endif // __ADDFUNCTION_H__
index 8280026..8d7c01d 100644 (file)
@@ -15,5 +15,6 @@
 #define C_GATEWAY_PROTOTYPE(__gateway__) int __gateway__(char* fname, void* pvApiCtx)
 typedef int (*OLDGW_FUNC)(char *fname, void* pvApiCtx);
 typedef int (*MEXGW_FUNC)(int nlhs, int* plhs[], int nrhs, int* prhs[]);
+#define MEX_GATEWAY_PROTOTYPE(__gateway__) int (__gateway__) (int nlhs, int* plhs[], int nrhs, int* prhs[]);
 
 #endif /* !__C_GATEWAY_PROTOTYPE_H__ */
index 2eada0b..ad2b821 100644 (file)
@@ -23,3 +23,8 @@ void addCFunction(wchar_t* _wstName, OLDGW_FUNC _pFunc, wchar_t* _wstModule)
 {
     symbol::Context::getInstance()->addFunction(types::Function::createFunction(_wstName, _pFunc, _wstModule));
 }
+
+void addMexFunction(wchar_t* _wstName, MEXGW_FUNC _pFunc, wchar_t* _wstModule)
+{
+    symbol::Context::getInstance()->addFunction(types::Function::createFunction(_wstName, _pFunc, _wstModule));
+}
index 742aa24..c1facba 100644 (file)
@@ -100,8 +100,19 @@ function gateway_filename = ilib_gen_gateway(name,tables)
             "#define MODULE_NAME L""" + tname + """";
             "";
             "int " + tname + "(wchar_t* _pwstFuncName)";
-            "{";
-            "    if(wcscmp(_pwstFuncName, L""" + table(:,1) + """) == 0){ " + "addCFunction(L""" + table(:,1) + """, &" + names(:) + ", MODULE_NAME); }";
+            "{";];
+
+            for kGw = 1:size(names, "*")
+                if or(table(kGw, 3) == ["cmex" "fmex" "Fmex"]) then
+                    t = [t;
+                    "    if(wcscmp(_pwstFuncName, L""" + table(:,1) + """) == 0){ " + "addMexFunction(L""" + table(:,1) + """, &" + names(:) + ", MODULE_NAME); }"];
+                else
+                    t = [t;
+                    "    if(wcscmp(_pwstFuncName, L""" + table(:,1) + """) == 0){ " + "addCFunction(L""" + table(:,1) + """, &" + names(:) + ", MODULE_NAME); }"];
+                end
+            end
+
+            t = [t;
             "";
             "    return 1;";
             "}"];
@@ -210,13 +221,13 @@ function [gate,names,cppCompilation] = new_names(table)
         select table(i,3)
         case "cmex" then
             names(i) = "mex_" + table(i,2);
-            gate(i, 1) = "C_GATEWAY_PROTOTYPE(" + names(i) + ");";
+            gate(i, 1) = "MEX_GATEWAY_PROTOTYPE(" + names(i) + ");";
         case "fmex" then
             names(i) = "C2F(mex" + table(i,2) + ")";
-            gate(i, 1) = "C_GATEWAY_PROTOTYPE(" + names(i) + ");";
+            gate(i, 1) = "MEX_GATEWAY_PROTOTYPE(" + names(i) + ");";
         case "Fmex" then
             names(i) = "C2F(mex" + table(i,2) + ")";
-            gate(i, 1) = "C_GATEWAY_PROTOTYPE(" + names(i) + ");";
+            gate(i, 1) = "MEX_GATEWAY_PROTOTYPE(" + names(i) + ");";
         case "csci"  then
             names(i) = table(i,2);
             gate(i, 1) = "C_GATEWAY_PROTOTYPE(" + names(i) + ");";
index 2d6d1ea..6b4c4eb 100644 (file)
@@ -31,6 +31,7 @@ function scilablibrarieslist = dlwGetScilabLibraries()
     "string.lib"; ..
     "threads.lib"; ..
     "sciconsole.lib"; ..
-    "scilab_windows.lib"];
+    "scilab_windows.lib"; ..
+    "libmex.lib"];
 endfunction
 //=============================================================================
index 78d4abd..cb67af9 100644 (file)
 // http://bugzilla.scilab.org/show_bug.cgi?id=614
 //
 // <-- Short Description -->
-//    mxGetDimensions() from mex.h and mexlib.c do not work 
-//    properly. The reason is that it returns a pointer to int 
-//    like Matlab, but in fact, the dimensions in scilab are in 
+//    mxGetDimensions() from mex.h and mexlib.c do not work
+//    properly. The reason is that it returns a pointer to int
+//    like Matlab, but in fact, the dimensions in scilab are in
 //    double format.
 //
 //    Also occur in other OS's.
 ilib_verbose(0);
 my_current_directory = pwd();
 cd(TMPDIR);
-mputl('ilib_mex_build(''libmex'',[''mexf16'',''mexfunction16'',''cmex''],[''mexfunction16.c''],[],[],'''','''','''')','builder.sce');
+mputl("ilib_mex_build(""libmextest"",[""mexf16"",""mexfunction16"",""cmex""],[""mexfunction16.c""],[],[],"""","""","""")","builder.sce");
 mputl([
-'#include ""mex.h""'
-'void mexFunction(nlhs, plhs, nrhs, prhs)'
-'     int nlhs, nrhs;'
-'     mxArray *plhs[]; mxArray *prhs[];'
-'{'
-'  int *dims = mxGetDimensions(prhs[0]);'
-'  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);'
-'}'
-],'mexfunction16.c');
-exec('builder.sce');
-exec('loader.sce');
+"#include ""mex.h"""
+"void mexFunction(nlhs, plhs, nrhs, prhs)"
+"     int nlhs, nrhs;"
+"     mxArray *plhs[]; mxArray *prhs[];"
+"{"
+"  int *dims = mxGetDimensions(prhs[0]);"
+"  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);"
+"}"
+],"mexfunction16.c");
+exec("builder.sce");
+exec("loader.sce");
 mexf16(rand(2,3,2))
 2 3 2
 cd(my_current_directory);
index ea840d7..92d7da3 100644 (file)
@@ -11,9 +11,9 @@
 // http://bugzilla.scilab.org/show_bug.cgi?id=614
 //
 // <-- Short Description -->
-//    mxGetDimensions() from mex.h and mexlib.c do not work 
-//    properly. The reason is that it returns a pointer to int 
-//    like Matlab, but in fact, the dimensions in scilab are in 
+//    mxGetDimensions() from mex.h and mexlib.c do not work
+//    properly. The reason is that it returns a pointer to int
+//    like Matlab, but in fact, the dimensions in scilab are in
 //    double format.
 //
 //    Also occur in other OS's.
@@ -22,21 +22,21 @@ ilib_verbose(0);
 
 my_current_directory = pwd();
 cd(TMPDIR);
-mputl('ilib_mex_build(''libmex'',[''mexf16'',''mexfunction16'',''cmex''],[''mexfunction16.c''],[],[],'''','''','''')','builder.sce');
+mputl("ilib_mex_build(""libmextest"",[""mexf16"",""mexfunction16"",""cmex""],[""mexfunction16.c""],[],[],"""","""","""")","builder.sce");
 
 mputl([
-'#include ""mex.h""'
-'void mexFunction(nlhs, plhs, nrhs, prhs)'
-'     int nlhs, nrhs;'
-'     mxArray *plhs[]; mxArray *prhs[];'
-'{'
-'  int *dims = mxGetDimensions(prhs[0]);'
-'  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);'
-'}'
-],'mexfunction16.c');
+"#include ""mex.h"""
+"void mexFunction(nlhs, plhs, nrhs, prhs)"
+"     int nlhs, nrhs;"
+"     mxArray *plhs[]; mxArray *prhs[];"
+"{"
+"  int *dims = mxGetDimensions(prhs[0]);"
+"  sciprint(""%d %d %d\n"",dims[0],dims[1],dims[2]);"
+"}"
+],"mexfunction16.c");
 
-exec('builder.sce');
-exec('loader.sce');
+exec("builder.sce");
+exec("loader.sce");
 
 mexf16(rand(2,3,2))
 
index 1d76ec8..4ccd92f 100644 (file)
@@ -1,37 +1,21 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mexCallMATLAB mex function
-
 // ============================================================================
-
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");';
-        '}'],'mexcallMATLAB.c');
-ilib_mex_build('libmextest', ['callMATLAB', 'mexcallMATLAB', 'cmex'], 'mexcallMATLAB.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");";
+        "}"],"mexcallMATLAB.c");
+ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", [], "", "", "", "");
+exec("loader.sce");
 res = callMATLAB([1 2 3 4]);
-
-if res <> 10 then pause end
+assert_checkequal(res, 10);
index 962a47a..ef943c9 100644 (file)
@@ -6,20 +6,19 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mexCallMATLAB mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");';
-        '}'],'mexcallMATLAB.c');
-ilib_mex_build('libmextest', ['callMATLAB', 'mexcallMATLAB', 'cmex'], 'mexcallMATLAB.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexCallMATLAB(nlhs, plhs, nrhs, prhs, ""sum"");";
+"}"],"mexcallMATLAB.c");
+ilib_mex_build("libmextest", ["callMATLAB", "mexcallMATLAB", "cmex"], "mexcallMATLAB.c", [], "", "", "", "");
+exec("loader.sce");
 
 res = callMATLAB([1 2 3 4]);
-if res <> 10 then pause end
+assert_checkequal(res, 10);
index 0ddfa17..c46359a 100644 (file)
@@ -1,55 +1,29 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mexEvalString mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char *string = mxArrayToString(prhs[0]);';
-       '    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));';
-       '}'],'mexevalString.c');
-
-ilib_mex_build('libmextest',['evalString','mexevalString','cmex'], 'mexevalString.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
-r = evalString('printf ""mexEvalString works!\n"";');
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    char *string = mxArrayToString(prhs[0]);";
+       "    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));";
+       "}"],"mexevalString.c");
+ilib_mex_build("libmextest",["evalString","mexevalString","cmex"], "mexevalString.c",[],"","","","");
+exec("loader.sce");
+r = evalString("printf ""mexEvalString works!\n"";");
 mexEvalString works!
-
-if r <> 0 then pause end
-
+assert_checkequal(r, 0);
 global a;
-
-r = evalString('a = 1;');
-
-if a <> 1 then pause end
-
-if r <> 0 then pause end
-
-r = evalString('b =;');
-
-if r <> 1 then pause end
-
+r = evalString("a = 1;");
+assert_checkequal(a, 1);
+assert_checkequal(r, 0);
+r = evalString("b =;");
+assert_checkequal(r, 1);
index 774e8b1..2f15fa9 100644 (file)
@@ -6,29 +6,28 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mexEvalString mex functions
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char *string = mxArrayToString(prhs[0]);';
-       '    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));';
-       '}'],'mexevalString.c');
-ilib_mex_build('libmextest',['evalString','mexevalString','cmex'], 'mexevalString.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *string = mxArrayToString(prhs[0]);";
+"    plhs[0] = mxCreateDoubleScalar(mexEvalString(string));";
+"}"],"mexevalString.c");
+ilib_mex_build("libmextest",["evalString","mexevalString","cmex"], "mexevalString.c",[],"","","","");
+exec("loader.sce");
 
-r = evalString('printf ""mexEvalString works!\n"";');
-if r <> 0 then pause end
+r = evalString("printf ""mexEvalString works!\n"";");
+assert_checkequal(r, 0);
 
 global a;
-r = evalString('a = 1;');
-if a <> 1 then pause end
-if r <> 0 then pause end
+r = evalString("a = 1;");
+assert_checkequal(a, 1);
+assert_checkequal(r, 0);
 
-r = evalString('b =;');
-if r <> 1 then pause end
+r = evalString("b =;");
+assert_checkequal(r, 1);
index 864dece..8764c52 100644 (file)
@@ -1,42 +1,24 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mexIsGlobal mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");';
-        '    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");';
-        '    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");';
-        '}'],'mexprintf.c');
-
-ilib_mex_build('libmextest', ['mprintf', 'mexprintf', 'cmex'], 'mexprintf.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");";
+        "    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");";
+        "    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");";
+        "}"],"mexprintf.c");
+ilib_mex_build("libmextest", ["mprintf", "mexprintf", "cmex"], "mexprintf.c", [], "", "", "", "");
+exec("loader.sce");
 mprintf();
 The quick brown fox jumps over the lazy dog.
 Some UTF-8 chars are áãâéíóúü.
index 11494ee..118103c 100644 (file)
@@ -6,21 +6,20 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mexIsGlobal mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");';
-        '    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");';
-        '    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");';
-        '}'],'mexprintf.c');
-ilib_mex_build('libmextest', ['mprintf', 'mexprintf', 'cmex'], 'mexprintf.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexPrintf(""The quick brown fox jumps over the lazy dog.\n"");";
+"    mexPrintf(""Some UTF-8 chars are áãâéíóúü.\n"");";
+"    mexPrintf(""Printing %s %s."", ""with"", ""parameters"");";
+"}"],"mexprintf.c");
+ilib_mex_build("libmextest", ["mprintf", "mexprintf", "cmex"], "mexprintf.c", [], "", "", "", "");
+exec("loader.sce");
 
 mprintf();
index 9474227..b089ac2 100644 (file)
@@ -1,54 +1,32 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mexPutFull mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    double pr[2] = {2, 5};';
-        '    double pi[2] = {3, 0};';
-        '    mexPutFull(""var1"", 2, 1, pr, NULL);';
-        '    plhs[0] = mexGetVariable(""caller"", ""var1"");';
-        '    mexPutFull(""var2"", 1, 2, pr, pi);';
-        '    plhs[1] = mexGetVariable(""caller"", ""var2"");';
-        '}'],'mexputFull.c');
-ilib_mex_build('libmextest', ['putFull', 'mexputFull', 'cmex'], 'mexputFull.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    double pr[2] = {2, 5};";
+        "    double pi[2] = {3, 0};";
+        "    mexPutFull(""var1"", 2, 1, pr, NULL);";
+        "    plhs[0] = mexGetVariable(""caller"", ""var1"");";
+        "    mexPutFull(""var2"", 1, 2, pr, pi);";
+        "    plhs[1] = mexGetVariable(""caller"", ""var2"");";
+        "}"],"mexputFull.c");
+ilib_mex_build("libmextest", ["putFull", "mexputFull", "cmex"], "mexputFull.c", [], "", "", "", "");
+exec("loader.sce");
 [out1, out2] = putFull();
-
-if exists("var1") <> 1 then pause end
-
-if exists("var2") <> 1 then pause end
-
-if out1(1) <> 2 then pause end
-
-if out1(2) <> 5 then pause end
-
-if out2(1) <> complex(2, 3) then pause end
-
-if out2(2) <> 5 then pause end
+assert_checktrue(exists("var1")==1);
+assert_checktrue(exists("var2")==1);
+assert_checkequal(out1(1), 2);
+assert_checkequal(out1(2), 5);
+assert_checkequal(out2(1), complex(2, 3));
+assert_checkequal(real(out2(2)), 5);
+assert_checkequal(imag(out2(2)), 0);
index 2717343..5ef33af 100644 (file)
@@ -6,30 +6,30 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mexPutFull mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    double pr[2] = {2, 5};';
-        '    double pi[2] = {3, 0};';
-        '    mexPutFull(""var1"", 2, 1, pr, NULL);';
-        '    plhs[0] = mexGetVariable(""caller"", ""var1"");';
-        '    mexPutFull(""var2"", 1, 2, pr, pi);';
-        '    plhs[1] = mexGetVariable(""caller"", ""var2"");';
-        '}'],'mexputFull.c');
-ilib_mex_build('libmextest', ['putFull', 'mexputFull', 'cmex'], 'mexputFull.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double pr[2] = {2, 5};";
+"    double pi[2] = {3, 0};";
+"    mexPutFull(""var1"", 2, 1, pr, NULL);";
+"    plhs[0] = mexGetVariable(""caller"", ""var1"");";
+"    mexPutFull(""var2"", 1, 2, pr, pi);";
+"    plhs[1] = mexGetVariable(""caller"", ""var2"");";
+"}"],"mexputFull.c");
+ilib_mex_build("libmextest", ["putFull", "mexputFull", "cmex"], "mexputFull.c", [], "", "", "", "");
+exec("loader.sce");
 
 [out1, out2] = putFull();
-if exists("var1") <> 1 then pause end
-if exists("var2") <> 1 then pause end
-if out1(1) <> 2 then pause end
-if out1(2) <> 5 then pause end
-if out2(1) <> complex(2, 3) then pause end
-if out2(2) <> 5 then pause end
\ No newline at end of file
+assert_checktrue(exists("var1")==1);
+assert_checktrue(exists("var2")==1);
+assert_checkequal(out1(1), 2);
+assert_checkequal(out1(2), 5);
+assert_checkequal(out2(1), complex(2, 3));
+assert_checkequal(real(out2(2)), 5);
+assert_checkequal(imag(out2(2)), 0);
index 2f8db86..639f25f 100644 (file)
@@ -1,64 +1,34 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mexPutVariable mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *workspace = mxArrayToString(prhs[0]);';
-        '    char *name = mxArrayToString(prhs[1]);';
-        '    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);';
-        '}'],'mexputVariable.c');
-
-ilib_mex_build('libmextest', ['putVariable', 'mexputVariable', 'cmex'], 'mexputVariable.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    char *workspace = mxArrayToString(prhs[0]);";
+        "    char *name = mxArrayToString(prhs[1]);";
+        "    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);";
+        "}"],"mexputVariable.c");
+ilib_mex_build("libmextest", ["putVariable", "mexputVariable", "cmex"], "mexputVariable.c", [], "", "", "", "");
+exec("loader.sce");
 global globalvar;
-
 putVariable("global", "globalvar", 32);
-
-if globalvar <> 32 then pause end
-
-if isglobal('globalvar') <> %t then pause end
-
+assert_checkequal(globalvar, 32);
+assert_checktrue(isglobal("globalvar"));
 othervar = 1;
-
 putVariable("base", "othervar", 3);
-
-if othervar <> 1 then pause end
-
-if isglobal('othervar') <> %f then pause end
-
+assert_checkequal(othervar, 1);
+assert_checkfalse(isglobal("othervar"));
 putVariable("caller", "othervar", 3);
-
-if othervar <> 3 then pause end
-
-if isglobal('othervar') <> %f then pause end
-
+assert_checkequal(othervar, 3);
+assert_checkfalse(isglobal("othervar"));
 putVariable("caller", "caller_defined_in_C", 0);
-
-if exists('caller_defined_in_C') <> 1 then pause end
+assert_checktrue(exists("caller_defined_in_C")==1);
index 0e5ef38..30c5b77 100644 (file)
@@ -6,36 +6,35 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mexPutVariable mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *workspace = mxArrayToString(prhs[0]);';
-        '    char *name = mxArrayToString(prhs[1]);';
-        '    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);';
-        '}'],'mexputVariable.c');
-ilib_mex_build('libmextest', ['putVariable', 'mexputVariable', 'cmex'], 'mexputVariable.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *workspace = mxArrayToString(prhs[0]);";
+"    char *name = mxArrayToString(prhs[1]);";
+"    mxArray *pOut = mexPutVariable(workspace, name, prhs[2]);";
+"}"],"mexputVariable.c");
+ilib_mex_build("libmextest", ["putVariable", "mexputVariable", "cmex"], "mexputVariable.c", [], "", "", "", "");
+exec("loader.sce");
 
 global globalvar;
 putVariable("global", "globalvar", 32);
-if globalvar <> 32 then pause end
-if isglobal('globalvar') <> %t then pause end
+assert_checkequal(globalvar, 32);
+assert_checktrue(isglobal("globalvar"));
 
 othervar = 1;
 putVariable("base", "othervar", 3);
-if othervar <> 1 then pause end
-if isglobal('othervar') <> %f then pause end
+assert_checkequal(othervar, 1);
+assert_checkfalse(isglobal("othervar"));
 
 putVariable("caller", "othervar", 3);
-if othervar <> 3 then pause end
-if isglobal('othervar') <> %f then pause end
+assert_checkequal(othervar, 3);
+assert_checkfalse(isglobal("othervar"));
 
 putVariable("caller", "caller_defined_in_C", 0);
-if exists('caller_defined_in_C') <> 1 then pause end
+assert_checktrue(exists("caller_defined_in_C")==1);
index 9b80ada..a0fbfd1 100644 (file)
@@ -1,40 +1,22 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
 // <-- ENGLISH IMPOSED -->
-
-// <-- INTERACTIVE TEST -->
-
 // ============================================================================
-
 // Unitary tests for mexWarnMsgTxt mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexWarnMsgTxt(""If you can read this message, mexWarnMsgTxt works!"");';
-       '}'],'mexwarnMsgTxt.c');
-ilib_mex_build('libmextest',['warnMsgTxt','mexwarnMsgTxt','cmex'], 'mexwarnMsgTxt.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");";
+       "}"],"mexwarnMsgTxt.c");
+ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[],"","","","");
+exec("loader.sce");
 warnMsgTxt()
-Warning: If you can read this message, mexWarnMsgTxt works!
+Warning: If you read this message, mexWarnMsgTxt works!
index e129e64..b51f78f 100644 (file)
@@ -7,7 +7,6 @@
 
 // <-- JVM NOT MANDATORY -->
 // <-- ENGLISH IMPOSED -->
-// <-- INTERACTIVE TEST -->
 // ============================================================================
 // Unitary tests for mexWarnMsgTxt mex function
 // ============================================================================
@@ -16,12 +15,12 @@ cd(TMPDIR);
 
 ilib_verbose(0);
 
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");';
-       '}'],'mexwarnMsgTxt.c');
-ilib_mex_build('libmextest',['warnMsgTxt','mexwarnMsgTxt','cmex'], 'mexwarnMsgTxt.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexWarnMsgTxt(""If you read this message, mexWarnMsgTxt works!"");";
+"}"],"mexwarnMsgTxt.c");
+ilib_mex_build("libmextest",["warnMsgTxt","mexwarnMsgTxt","cmex"], "mexwarnMsgTxt.c",[],"","","","");
+exec("loader.sce");
 
 warnMsgTxt()
index 5113444..75291e5 100644 (file)
@@ -1,45 +1,24 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxAddField mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mxArray *ptr = prhs[0];'
-        '    int fieldnumber = mxAddField(ptr, ""another"");';
-        '    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));';
-        '}'],'mexaddField.c');
-
-ilib_mex_build('libmextest', ['addField', 'mexaddField', 'cmex'], 'mexaddField.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    mxArray *ptr = prhs[0];"
+        "    int fieldnumber = mxAddField(ptr, ""another"");";
+        "    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));";
+        "}"],"mexaddField.c");
+ilib_mex_build("libmextest", ["addField", "mexaddField", "cmex"], "mexaddField.c", [], "", "", "", "");
+exec("loader.sce");
 s = struct();
-
 addField(s);
-
-if s("another") <> 3 then pause end
-
+assert_checkequal(s("another"), 3);
index 3471ff9..b4e84af 100644 (file)
@@ -6,23 +6,22 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxAddField mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    mxArray *ptr = prhs[0];'
-        '    int fieldnumber = mxAddField(ptr, ""another"");';
-        '    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));';
-        '}'],'mexaddField.c');
-ilib_mex_build('libmextest', ['addField', 'mexaddField', 'cmex'], 'mexaddField.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *ptr = prhs[0];"
+"    int fieldnumber = mxAddField(ptr, ""another"");";
+"    mxSetFieldByNumber(ptr, 0, fieldnumber, mxCreateDoubleScalar(3));";
+"}"],"mexaddField.c");
+ilib_mex_build("libmextest", ["addField", "mexaddField", "cmex"], "mexaddField.c", [], "", "", "", "");
+exec("loader.sce");
 
 s = struct();
 addField(s);
-if s("another") <> 3 then pause end
+assert_checkequal(s("another"), 3);
index abb3699..183d587 100644 (file)
@@ -1,41 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxArrayToString mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *str = mxArrayToString(prhs[0]);';
-        '    mexPrintf(""%s"", str);';
-        '}'],'mexArrayToString.c');
-
-ilib_mex_build('libmextest', ['arrayToString', 'mexArrayToString', 'cmex'], 'mexArrayToString.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    char *str = mxArrayToString(prhs[0]);";
+        "    mexPrintf(""%s"", str);";
+        "}"],"mexArrayToString.c");
+ilib_mex_build("libmextest", ["arrayToString", "mexArrayToString", "cmex"], "mexArrayToString.c", [], "", "", "", "");
+exec("loader.sce");
 arrayToString("hello world");
 hello world
 arrayToString(["two"; "lines"]);
index 3231455..634b3fb 100644 (file)
@@ -6,21 +6,20 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxArrayToString mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *str = mxArrayToString(prhs[0]);';
-        '    mexPrintf(""%s"", str);';
-        '}'],'mexArrayToString.c');
-ilib_mex_build('libmextest', ['arrayToString', 'mexArrayToString', 'cmex'], 'mexArrayToString.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *str = mxArrayToString(prhs[0]);";
+"    mexPrintf(""%s"", str);";
+"}"],"mexArrayToString.c");
+ilib_mex_build("libmextest", ["arrayToString", "mexArrayToString", "cmex"], "mexArrayToString.c", [], "", "", "", "");
+exec("loader.sce");
 
 arrayToString("hello world");
 arrayToString(["two"; "lines"]);
index 7176b8e..56d2446 100644 (file)
@@ -1,75 +1,39 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCalcSingleSubscript mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    int *dims = mxGetData(prhs[2]);';
-        '    int ndim = mxGetScalar(prhs[1]);';
-        '    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));';
-        '}'],'mexcalcSingleSubscript.c');
-
-ilib_mex_build('libmextest', ['calcSingleSubscript', 'mexcalcSingleSubscript', 'cmex'], 'mexcalcSingleSubscript.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    int *dims = mxGetData(prhs[2]);";
+        "    int ndim = mxGetScalar(prhs[1]);";
+        "    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));";
+        "}"],"mexcalcSingleSubscript.c");
+ilib_mex_build("libmextest", ["calcSingleSubscript", "mexcalcSingleSubscript", "cmex"], "mexcalcSingleSubscript.c", [], "", "", "", "");
+exec("loader.sce");
 a = zeros(3, 3);
-
 r = calcSingleSubscript(a, 2, int32([0 0]));
-
-if r <> 0 then pause end
-
+assert_checkequal(r, 0);
 r = calcSingleSubscript(a, 2, int32([1 1]));
-
-if r <> 4 then pause end
-
+assert_checkequal(r, 4);
 r = calcSingleSubscript(a, 2, int32([2 2]));
-
-if r <> 8 then pause end
-
+assert_checkequal(r, 8);
 b = zeros(4, 2, 3);
-
 r = calcSingleSubscript(b, 3, int32([0 0 0]));
-
-if r <> 0 then pause end
-
+assert_checkequal(r, 0);
 r = calcSingleSubscript(b, 2, int32([0 0]));
-
-if r <> 0 then pause end
-
+assert_checkequal(r, 0);
 r = calcSingleSubscript(b, 3, int32([3 0 2]));
-
-if r <> 19 then pause end
-
+assert_checkequal(r, 19);
 r = calcSingleSubscript(b, 3, int32([1 1 1]));
-
-if r <> 13 then pause end
-
+assert_checkequal(r, 13);
 r = calcSingleSubscript(b, 3, int32([3 1 2]));
-
-if r <> 23 then pause end
-
+assert_checkequal(r, 23);
index 981eb00..1c127a9 100644 (file)
@@ -6,39 +6,38 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCalcSingleSubscript mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    int *dims = mxGetData(prhs[2]);';
-        '    int ndim = mxGetScalar(prhs[1]);';
-        '    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));';
-        '}'],'mexcalcSingleSubscript.c');
-ilib_mex_build('libmextest', ['calcSingleSubscript', 'mexcalcSingleSubscript', 'cmex'], 'mexcalcSingleSubscript.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int *dims = mxGetData(prhs[2]);";
+"    int ndim = mxGetScalar(prhs[1]);";
+"    plhs[0] = mxCreateDoubleScalar(mxCalcSingleSubscript(prhs[0], ndim, dims));";
+"}"],"mexcalcSingleSubscript.c");
+ilib_mex_build("libmextest", ["calcSingleSubscript", "mexcalcSingleSubscript", "cmex"], "mexcalcSingleSubscript.c", [], "", "", "", "");
+exec("loader.sce");
 
 a = zeros(3, 3);
 r = calcSingleSubscript(a, 2, int32([0 0]));
-if r <> 0 then pause end
+assert_checkequal(r, 0);
 r = calcSingleSubscript(a, 2, int32([1 1]));
-if r <> 4 then pause end
+assert_checkequal(r, 4);
 r = calcSingleSubscript(a, 2, int32([2 2]));
-if r <> 8 then pause end
+assert_checkequal(r, 8);
 
 b = zeros(4, 2, 3);
 r = calcSingleSubscript(b, 3, int32([0 0 0]));
-if r <> 0 then pause end
+assert_checkequal(r, 0);
 r = calcSingleSubscript(b, 2, int32([0 0]));
-if r <> 0 then pause end
+assert_checkequal(r, 0);
 r = calcSingleSubscript(b, 3, int32([3 0 2]));
-if r <> 19 then pause end
+assert_checkequal(r, 19);
 r = calcSingleSubscript(b, 3, int32([1 1 1]));
-if r <> 13 then pause end
+assert_checkequal(r, 13);
 r = calcSingleSubscript(b, 3, int32([3 1 2]));
-if r <> 23 then pause end
+assert_checkequal(r, 23);
index 688bebe..1d0a98a 100644 (file)
@@ -1,93 +1,72 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsCell, mxIsChar, mxIsDouble, mxIsFunction,
-
 // mxIsInt8, mxIsInt16, mxIsInt32, mxIsInt64,
-
 // mxIsUint8, mxIsUint16, mxIsUint32, mxIsUint64,
-
 // mxIsLogical, mxIsStruct and mxIsSingle mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxIsCell(prhs[0])) {';
-       '        mexPrintf(""cell"");';
-       '    }'
-       '    if (mxIsChar(prhs[0])) {';
-       '        mexPrintf(""char"");';
-       '    }'
-       '    if (mxIsDouble(prhs[0])) {';
-       '        mexPrintf(""double"");';
-       '    }'
-       '    if (mxIsFunction(prhs[0])) {';
-       '        mexPrintf(""function_handle"");';
-       '    }'
-       '    if (mxIsInt8(prhs[0])) {';
-       '        mexPrintf(""int8"");';
-       '    }'
-       '    if (mxIsInt16(prhs[0])) {';
-       '        mexPrintf(""int16"");';
-       '    }'
-       '    if (mxIsInt32(prhs[0])) {';
-       '        mexPrintf(""int32"");';
-       '    }'
-       '    if (mxIsInt64(prhs[0])) {';
-       '        mexPrintf(""int64"");';
-       '    }'
-       '    if (mxIsLogical(prhs[0])) {';
-       '        mexPrintf(""logical"");';
-       '    }'
-       '    if (mxIsSingle(prhs[0])) {';
-       '        mexPrintf(""single"");';
-       '    }'
-       '    if (mxIsStruct(prhs[0])) {';
-       '        mexPrintf(""struct"");';
-       '    }'
-       '    if (mxIsUint8(prhs[0])) {';
-       '        mexPrintf(""uint8"");';
-       '    }'
-       '    if (mxIsUint16(prhs[0])) {';
-       '        mexPrintf(""uint16"");';
-       '    }'
-       '    if (mxIsUint32(prhs[0])) {';
-       '        mexPrintf(""uint32"");';
-       '    }'
-       '    if (mxIsUint64(prhs[0])) {';
-       '        mexPrintf(""uint64"");';
-       '    }'
-       '}'],'mexcheckTypes.c');
-
-ilib_mex_build('libmextest',['printClass','mexcheckTypes','cmex'], 'mexcheckTypes.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxIsCell(prhs[0])) {";
+"        mexPrintf(""cell"");";
+"    }"
+"    if (mxIsChar(prhs[0])) {";
+"        mexPrintf(""char"");";
+"    }"
+"    if (mxIsDouble(prhs[0])) {";
+"        mexPrintf(""double"");";
+"    }"
+"    if (mxIsFunction(prhs[0])) {";
+"        mexPrintf(""function_handle"");";
+"    }"
+"    if (mxIsInt8(prhs[0])) {";
+"        mexPrintf(""int8"");";
+"    }"
+"    if (mxIsInt16(prhs[0])) {";
+"        mexPrintf(""int16"");";
+"    }"
+"    if (mxIsInt32(prhs[0])) {";
+"        mexPrintf(""int32"");";
+"    }"
+"    if (mxIsInt64(prhs[0])) {";
+"        mexPrintf(""int64"");";
+"    }"
+"    if (mxIsLogical(prhs[0])) {";
+"        mexPrintf(""logical"");";
+"    }"
+"    if (mxIsSingle(prhs[0])) {";
+"        mexPrintf(""single"");";
+"    }"
+"    if (mxIsStruct(prhs[0])) {";
+"        mexPrintf(""struct"");";
+"    }"
+"    if (mxIsUint8(prhs[0])) {";
+"        mexPrintf(""uint8"");";
+"    }"
+"    if (mxIsUint16(prhs[0])) {";
+"        mexPrintf(""uint16"");";
+"    }"
+"    if (mxIsUint32(prhs[0])) {";
+"        mexPrintf(""uint32"");";
+"    }"
+"    if (mxIsUint64(prhs[0])) {";
+"        mexPrintf(""uint64"");";
+"    }"
+"}"],"mexcheckTypes.c");
+ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[],"","","","");
+exec("loader.sce");
 printClass(cell());
 cell
-printClass('s');
+printClass("s");
 char
 printClass(1);
 double
index 4160084..db8a7d2 100644 (file)
@@ -6,7 +6,6 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsCell, mxIsChar, mxIsDouble, mxIsFunction,
 // mxIsInt8, mxIsInt16, mxIsInt32, mxIsInt64,
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxIsCell(prhs[0])) {';
-       '        mexPrintf(""cell"");';
-       '    }'
-       '    if (mxIsChar(prhs[0])) {';
-       '        mexPrintf(""char"");';
-       '    }'
-       '    if (mxIsDouble(prhs[0])) {';
-       '        mexPrintf(""double"");';
-       '    }'
-       '    if (mxIsFunction(prhs[0])) {';
-       '        mexPrintf(""function_handle"");';
-       '    }'
-       '    if (mxIsInt8(prhs[0])) {';
-       '        mexPrintf(""int8"");';
-       '    }'
-       '    if (mxIsInt16(prhs[0])) {';
-       '        mexPrintf(""int16"");';
-       '    }'
-       '    if (mxIsInt32(prhs[0])) {';
-       '        mexPrintf(""int32"");';
-       '    }'
-       '    if (mxIsInt64(prhs[0])) {';
-       '        mexPrintf(""int64"");';
-       '    }'
-       '    if (mxIsLogical(prhs[0])) {';
-       '        mexPrintf(""logical"");';
-       '    }'
-       '    if (mxIsSingle(prhs[0])) {';
-       '        mexPrintf(""single"");';
-       '    }'
-       '    if (mxIsStruct(prhs[0])) {';
-       '        mexPrintf(""struct"");';
-       '    }'
-       '    if (mxIsUint8(prhs[0])) {';
-       '        mexPrintf(""uint8"");';
-       '    }'
-       '    if (mxIsUint16(prhs[0])) {';
-       '        mexPrintf(""uint16"");';
-       '    }'
-       '    if (mxIsUint32(prhs[0])) {';
-       '        mexPrintf(""uint32"");';
-       '    }'
-       '    if (mxIsUint64(prhs[0])) {';
-       '        mexPrintf(""uint64"");';
-       '    }'
-       '}'],'mexcheckTypes.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxIsCell(prhs[0])) {";
+"        mexPrintf(""cell"");";
+"    }"
+"    if (mxIsChar(prhs[0])) {";
+"        mexPrintf(""char"");";
+"    }"
+"    if (mxIsDouble(prhs[0])) {";
+"        mexPrintf(""double"");";
+"    }"
+"    if (mxIsFunction(prhs[0])) {";
+"        mexPrintf(""function_handle"");";
+"    }"
+"    if (mxIsInt8(prhs[0])) {";
+"        mexPrintf(""int8"");";
+"    }"
+"    if (mxIsInt16(prhs[0])) {";
+"        mexPrintf(""int16"");";
+"    }"
+"    if (mxIsInt32(prhs[0])) {";
+"        mexPrintf(""int32"");";
+"    }"
+"    if (mxIsInt64(prhs[0])) {";
+"        mexPrintf(""int64"");";
+"    }"
+"    if (mxIsLogical(prhs[0])) {";
+"        mexPrintf(""logical"");";
+"    }"
+"    if (mxIsSingle(prhs[0])) {";
+"        mexPrintf(""single"");";
+"    }"
+"    if (mxIsStruct(prhs[0])) {";
+"        mexPrintf(""struct"");";
+"    }"
+"    if (mxIsUint8(prhs[0])) {";
+"        mexPrintf(""uint8"");";
+"    }"
+"    if (mxIsUint16(prhs[0])) {";
+"        mexPrintf(""uint16"");";
+"    }"
+"    if (mxIsUint32(prhs[0])) {";
+"        mexPrintf(""uint32"");";
+"    }"
+"    if (mxIsUint64(prhs[0])) {";
+"        mexPrintf(""uint64"");";
+"    }"
+"}"],"mexcheckTypes.c");
 
-ilib_mex_build('libmextest',['printClass','mexcheckTypes','cmex'], 'mexcheckTypes.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["printClass","mexcheckTypes","cmex"], "mexcheckTypes.c",[],"","","","");
+exec("loader.sce");
 
 printClass(cell());
-printClass('s');
+printClass("s");
 printClass(1);
 printClass(sum);
 printClass(int8(1));
index cae8ebb..f204feb 100644 (file)
@@ -1,58 +1,32 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateCellArray and mxCreateCellMatrix mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *pOut1 = mxCreateCellMatrix(2, 2);';
-       '    int dims[2] = {3, 3};';
-       '    mxArray *pOut2 = mxCreateCellArray(2, dims);';
-       '    plhs[0] = pOut1;';
-       '    plhs[1] = pOut2;';
-       '}'],'mexCreateCell.c');
-
-ilib_mex_build('libmextest',['createCell','mexCreateCell','cmex'], 'mexCreateCell.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
-[out1, out2] = createCell()
-out2  = 
-
-  [0x0 constant]  [0x0 constant]  [0x0 constant]
-  [0x0 constant]  [0x0 constant]  [0x0 constant]
-  [0x0 constant]  [0x0 constant]  [0x0 constant]
-
-out1  = 
-
-  [0x0 constant]  [0x0 constant]
-  [0x0 constant]  [0x0 constant]
-
-
-if size(out1) <> [2, 2] then pause end;
-
-if size(out2) <> [3, 3] then pause end;
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxArray *pOut1 = mxCreateCellMatrix(2, 2);";
+       "    int dims[2] = {3, 3};";
+       "    mxArray *pOut2 = mxCreateCellArray(2, dims);";
+       "    plhs[0] = pOut1;";
+       "    plhs[1] = pOut2;";
+       "}"],"mexCreateCell.c");
+ilib_mex_build("libmextest",["createCell","mexCreateCell","cmex"], "mexCreateCell.c",[],"","","","");
+exec("loader.sce");
+[out1, out2] = createCell();
+assert_checkequal(size(out1), [2, 2]);
+for k=1:size(out1, "*")
+    assert_checkequal(out1{k}, []);
+end
+assert_checkequal(size(out2), [3, 3]);
+for k=1:size(out2, "*")
+    assert_checkequal(out2{k}, []);
+end
index 09b3831..ddc7932 100644 (file)
@@ -6,25 +6,30 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateCellArray and mxCreateCellMatrix mex functions
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *pOut1 = mxCreateCellMatrix(2, 2);';
-       '    int dims[2] = {3, 3};';
-       '    mxArray *pOut2 = mxCreateCellArray(2, dims);';
-       '    plhs[0] = pOut1;';
-       '    plhs[1] = pOut2;';
-       '}'],'mexCreateCell.c');
-ilib_mex_build('libmextest',['createCell','mexCreateCell','cmex'], 'mexCreateCell.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *pOut1 = mxCreateCellMatrix(2, 2);";
+"    int dims[2] = {3, 3};";
+"    mxArray *pOut2 = mxCreateCellArray(2, dims);";
+"    plhs[0] = pOut1;";
+"    plhs[1] = pOut2;";
+"}"],"mexCreateCell.c");
+ilib_mex_build("libmextest",["createCell","mexCreateCell","cmex"], "mexCreateCell.c",[],"","","","");
+exec("loader.sce");
 
-[out1, out2] = createCell()
-if size(out1) <> [2, 2] then pause end;
-if size(out2) <> [3, 3] then pause end;
+[out1, out2] = createCell();
+assert_checkequal(size(out1), [2, 2]);
+for k=1:size(out1, "*")
+    assert_checkequal(out1{k}, []);
+end
+assert_checkequal(size(out2), [3, 3]);
+for k=1:size(out2, "*")
+    assert_checkequal(out2{k}, []);
+end
index 2515b59..8af9dfa 100644 (file)
@@ -1,44 +1,27 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateCharMatrixFromStrings mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *strings[2];';
-        '    strings[0] = ""value"";';
-        '    strings[1] = ""another value"";';
-        '    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);';
-        '    char *res = mxArrayToString(pOut);';
-        '    plhs[0] = pOut;';
-        '}'],'mexcreateCharMatrixFromStrings.c');
-ilib_mex_build('libmextest', ['createCharMatrixFromStrings', 'mexcreateCharMatrixFromStrings', 'cmex'], 'mexcreateCharMatrixFromStrings.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    char *strings[2];";
+        "    strings[0] = ""value"";";
+        "    strings[1] = ""another value"";";
+        "    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);";
+        "    char *res = mxArrayToString(pOut);";
+        "    plhs[0] = pOut;";
+        "}"],"mexcreateCharMatrixFromStrings.c");
+ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", [], "", "", "", "");
+exec("loader.sce");
 res = createCharMatrixFromStrings();
-if res(1) <> "value" then pause end
-if res(2) <> "another value" then pause end
+assert_checkequal(res(1), "value");
+assert_checkequal(res(2), "another value");
index cc7d9c0..44f63a9 100644 (file)
@@ -6,26 +6,25 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateCharMatrixFromStrings mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    char *strings[2];';
-        '    strings[0] = ""value"";';
-        '    strings[1] = ""another value"";';
-        '    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);';
-        '    char *res = mxArrayToString(pOut);';
-        '    plhs[0] = pOut;';
-        '}'],'mexcreateCharMatrixFromStrings.c');
-ilib_mex_build('libmextest', ['createCharMatrixFromStrings', 'mexcreateCharMatrixFromStrings', 'cmex'], 'mexcreateCharMatrixFromStrings.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *strings[2];";
+"    strings[0] = ""value"";";
+"    strings[1] = ""another value"";";
+"    mxArray *pOut = mxCreateCharMatrixFromStrings(2, strings);";
+"    char *res = mxArrayToString(pOut);";
+"    plhs[0] = pOut;";
+"}"],"mexcreateCharMatrixFromStrings.c");
+ilib_mex_build("libmextest", ["createCharMatrixFromStrings", "mexcreateCharMatrixFromStrings", "cmex"], "mexcreateCharMatrixFromStrings.c", [], "", "", "", "");
+exec("loader.sce");
 
 res = createCharMatrixFromStrings();
-if res(1) <> "value" then pause end
-if res(2) <> "another value" then pause end
\ No newline at end of file
+assert_checkequal(res(1), "value");
+assert_checkequal(res(2), "another value");
\ No newline at end of file
index 0ad6b58..313f009 100644 (file)
@@ -1,71 +1,48 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateDoubleMatrix, mxCreateDoubleScalar mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   double dblM = 0;';
-        '   double dblN = 0;';
-        '   double *pdbl = NULL;';
-        '   mxArray* pOut1 = NULL;';
-        '   mxArray* pOut2 = NULL;';
-        '';
-        '   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   dblM = mxGetScalar(prhs[0]);';
-        '   dblN = mxGetScalar(prhs[1]);';
-        '   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);';
-        '   pOut2 = mxCreateDoubleScalar(dblM * dblN);';
-        '   pdbl = mxGetPr(pOut1);';
-        '   for(i = 0 ; i < dblM * dblN ; i++)';
-        '   {';
-        '       pdbl[i] = i+1;';
-        '   }';
-        '';
-        '   plhs[0] = pOut1;';
-        '   plhs[1] = pOut2;';
-        '}'],'mexCreateDoubleScalar.c');
-
-ilib_mex_build('libmextest',['createDouble','mexCreateDoubleScalar','cmex'],'mexCreateDoubleScalar.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int i = 0;";
+        "   double dblM = 0;";
+        "   double dblN = 0;";
+        "   double *pdbl = NULL;";
+        "   mxArray* pOut1 = NULL;";
+        "   mxArray* pOut2 = NULL;";
+        "";
+        "   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   dblM = mxGetScalar(prhs[0]);";
+        "   dblN = mxGetScalar(prhs[1]);";
+        "   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);";
+        "   pOut2 = mxCreateDoubleScalar(dblM * dblN);";
+        "   pdbl = mxGetPr(pOut1);";
+        "   for(i = 0 ; i < dblM * dblN ; i++)";
+        "   {";
+        "       pdbl[i] = i+1;";
+        "   }";
+        "";
+        "   plhs[0] = pOut1;";
+        "   plhs[1] = pOut2;";
+        "}"],"mexCreateDoubleScalar.c");
+ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[],"","","","");
+exec("loader.sce");
 m = 3;
-
 n = 4;
-
 [a,b] = createDouble(m, n);
-
-if b <> m*n then pause end
-
-if or(a(:)' <>  (1:m*n)) then pause end
-
+assert_checkequal(b, m*n);
+assert_checkequal(a(:)', 1:m*n);
index f9435dd..782efa6 100644 (file)
@@ -6,47 +6,46 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateDoubleMatrix, mxCreateDoubleScalar mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   double dblM = 0;';
-        '   double dblN = 0;';
-        '   double *pdbl = NULL;';
-        '   mxArray* pOut1 = NULL;';
-        '   mxArray* pOut2 = NULL;';
-        '';
-        '   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   dblM = mxGetScalar(prhs[0]);';
-        '   dblN = mxGetScalar(prhs[1]);';
-        '   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);';
-        '   pOut2 = mxCreateDoubleScalar(dblM * dblN);';
-        '   pdbl = mxGetPr(pOut1);';
-        '   for(i = 0 ; i < dblM * dblN ; i++)';
-        '   {';
-        '       pdbl[i] = i+1;';
-        '   }';
-        '';
-        '   plhs[0] = pOut1;';
-        '   plhs[1] = pOut2;';
-        '}'],'mexCreateDoubleScalar.c');
-ilib_mex_build('libmextest',['createDouble','mexCreateDoubleScalar','cmex'],'mexCreateDoubleScalar.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   double dblM = 0;";
+"   double dblN = 0;";
+"   double *pdbl = NULL;";
+"   mxArray* pOut1 = NULL;";
+"   mxArray* pOut2 = NULL;";
+"";
+"   if(nrhs != 2 || nlhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   dblM = mxGetScalar(prhs[0]);";
+"   dblN = mxGetScalar(prhs[1]);";
+"   pOut1 = mxCreateDoubleMatrix((int)dblM, (int)dblN, mxREAL);";
+"   pOut2 = mxCreateDoubleScalar(dblM * dblN);";
+"   pdbl = mxGetPr(pOut1);";
+"   for(i = 0 ; i < dblM * dblN ; i++)";
+"   {";
+"       pdbl[i] = i+1;";
+"   }";
+"";
+"   plhs[0] = pOut1;";
+"   plhs[1] = pOut2;";
+"}"],"mexCreateDoubleScalar.c");
+ilib_mex_build("libmextest",["createDouble","mexCreateDoubleScalar","cmex"],"mexCreateDoubleScalar.c",[],"","","","");
+exec("loader.sce");
 
 m = 3;
 n = 4;
 [a,b] = createDouble(m, n);
-if b <> m*n then pause end
-if or(a(:)' <>  (1:m*n)) then pause end
+assert_checkequal(b, m*n);
+assert_checkequal(a(:)', 1:m*n);
index ae443f7..65debde 100644 (file)
@@ -1,46 +1,25 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateLogicalArray mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int ndim = (int) mxGetScalar(prhs[0]);';
-        '   int *dims = (int *) mxGetData(prhs[1]);';
-        '   plhs[0] = mxCreateLogicalArray(ndim, dims);';
-        '}'],'mexCreateLogicalArray.c');
-
-ilib_mex_build('libmextest',['createLogicalArray', 'mexCreateLogicalArray', 'cmex'], 'mexCreateLogicalArray.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int ndim = (int) mxGetScalar(prhs[0]);";
+        "   int *dims = (int *) mxGetData(prhs[1]);";
+        "   plhs[0] = mxCreateLogicalArray(ndim, dims);";
+        "}"],"mexCreateLogicalArray.c");
+ilib_mex_build("libmextest",["createLogicalArray", "mexCreateLogicalArray", "cmex"], "mexCreateLogicalArray.c", [], "", "", "", "");
+exec("loader.sce");
 a = createLogicalArray(4, int32([2 2 2 2]));
-
-if size(a, "*") <> 16 then pause end
-
-if typeof(a) <> "boolean" then pause end
-
+assert_checkequal(size(a, "*"), 16);
+assert_checkequal(typeof(a), "boolean");
index 8cdf956..d2b6c83 100644 (file)
@@ -6,24 +6,23 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateLogicalArray mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int ndim = (int) mxGetScalar(prhs[0]);';
-        '   int *dims = (int *) mxGetData(prhs[1]);';
-        '   plhs[0] = mxCreateLogicalArray(ndim, dims);';
-        '}'],'mexCreateLogicalArray.c');
-ilib_mex_build('libmextest',['createLogicalArray', 'mexCreateLogicalArray', 'cmex'], 'mexCreateLogicalArray.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int ndim = (int) mxGetScalar(prhs[0]);";
+"   int *dims = (int *) mxGetData(prhs[1]);";
+"   plhs[0] = mxCreateLogicalArray(ndim, dims);";
+"}"],"mexCreateLogicalArray.c");
+ilib_mex_build("libmextest",["createLogicalArray", "mexCreateLogicalArray", "cmex"], "mexCreateLogicalArray.c", [], "", "", "", "");
+exec("loader.sce");
 
 a = createLogicalArray(4, int32([2 2 2 2]));
-if size(a, "*") <> 16 then pause end
-if typeof(a) <> "boolean" then pause end
+assert_checkequal(size(a, "*"), 16);
+assert_checkequal(typeof(a), "boolean");
index b4afa03..3077920 100644 (file)
@@ -1,56 +1,35 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateLogicalMatrix mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   double* pdblM = NULL;';
-        '   double* pdblN = NULL;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pdblM = mxGetPr(prhs[0]);';
-        '   pdblN = mxGetPr(prhs[1]);';
-        '   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateLogicalMatrix.c');
-
-ilib_mex_build('libmextest',['createLogicalMatrix', 'mexCreateLogicalMatrix', 'cmex'], 'mexCreateLogicalMatrix.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   double* pdblM = NULL;";
+        "   double* pdblN = NULL;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   pdblM = mxGetPr(prhs[0]);";
+        "   pdblN = mxGetPr(prhs[1]);";
+        "   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);";
+        "   plhs[0] = pOut;";
+        "}"],"mexCreateLogicalMatrix.c");
+ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", [], "", "", "", "");
+exec("loader.sce");
 a = createLogicalMatrix(4,3);
-
-if size(a, "*") <> 12 then pause end
-
-if typeof(a) <> "boolean" then pause end
-
+assert_checkequal(size(a, "*"), 12);
+assert_checkequal(typeof(a), "boolean");
index cf9c142..b919444 100644 (file)
@@ -6,34 +6,33 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateLogicalMatrix mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   double* pdblM = NULL;';
-        '   double* pdblN = NULL;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pdblM = mxGetPr(prhs[0]);';
-        '   pdblN = mxGetPr(prhs[1]);';
-        '   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateLogicalMatrix.c');
-ilib_mex_build('libmextest',['createLogicalMatrix', 'mexCreateLogicalMatrix', 'cmex'], 'mexCreateLogicalMatrix.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   double* pdblM = NULL;";
+"   double* pdblN = NULL;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 2 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pdblM = mxGetPr(prhs[0]);";
+"   pdblN = mxGetPr(prhs[1]);";
+"   pOut = mxCreateLogicalMatrix((int)pdblM[0], (int)pdblN[0]);";
+"   plhs[0] = pOut;";
+"}"],"mexCreateLogicalMatrix.c");
+ilib_mex_build("libmextest",["createLogicalMatrix", "mexCreateLogicalMatrix", "cmex"], "mexCreateLogicalMatrix.c", [], "", "", "", "");
+exec("loader.sce");
 
 a = createLogicalMatrix(4,3);
-if size(a, "*") <> 12 then pause end
-if typeof(a) <> "boolean" then pause end
+assert_checkequal(size(a, "*"), 12);
+assert_checkequal(typeof(a), "boolean");
index 0a6c9ef..895cd13 100644 (file)
@@ -1,61 +1,41 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
 // <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateLogicalScalar mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int bIn1 = 0;';
-        '   int bIn2 = 0;';
-        '   mxArray* pOut1 = NULL;';
-        '   mxArray* pOut2 = NULL;';
-        '';
-        '   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   bIn1 = mxIsLogicalScalarTrue(prhs[0]);';
-        '   bIn2 = mxIsLogicalScalarTrue(prhs[1]);';
-        '';
-        '   pOut1 = mxCreateLogicalScalar(!bIn1);';
-        '   pOut2 = mxCreateLogicalScalar(!bIn2);';
-        '';
-        '   plhs[0] = pOut1;';
-        '   plhs[1] = pOut2;';
-        '}'],'mexCreateLogicalScalar.c');
-
-ilib_mex_build('libmextest', ['createLogicalScalar', 'mexCreateLogicalScalar', 'cmex'], 'mexCreateLogicalScalar.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int bIn1 = 0;";
+        "   int bIn2 = 0;";
+        "   mxArray* pOut1 = NULL;";
+        "   mxArray* pOut2 = NULL;";
+        "";
+        "   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   bIn1 = mxIsLogicalScalarTrue(prhs[0]);";
+        "   bIn2 = mxIsLogicalScalarTrue(prhs[1]);";
+        "";
+        "   pOut1 = mxCreateLogicalScalar(!bIn1);";
+        "   pOut2 = mxCreateLogicalScalar(!bIn2);";
+        "";
+        "   plhs[0] = pOut1;";
+        "   plhs[1] = pOut2;";
+        "}"],"mexCreateLogicalScalar.c");
+ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", [], "", "", "", "");
+exec("loader.sce");
 [out1, out2] = createLogicalScalar(%t, %f);
-
-if out1 <> %f then pause end
-
-if out2 <> %t then pause end
-
+assert_checkfalse(out1);
+assert_checktrue(out2);
index 03c5572..279a9ec 100644 (file)
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int bIn1 = 0;';
-        '   int bIn2 = 0;';
-        '   mxArray* pOut1 = NULL;';
-        '   mxArray* pOut2 = NULL;';
-        '';
-        '   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   bIn1 = mxIsLogicalScalarTrue(prhs[0]);';
-        '   bIn2 = mxIsLogicalScalarTrue(prhs[1]);';
-        '';
-        '   pOut1 = mxCreateLogicalScalar(!bIn1);';
-        '   pOut2 = mxCreateLogicalScalar(!bIn2);';
-        '';
-        '   plhs[0] = pOut1;';
-        '   plhs[1] = pOut2;';
-        '}'],'mexCreateLogicalScalar.c');
-ilib_mex_build('libmextest', ['createLogicalScalar', 'mexCreateLogicalScalar', 'cmex'], 'mexCreateLogicalScalar.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int bIn1 = 0;";
+"   int bIn2 = 0;";
+"   mxArray* pOut1 = NULL;";
+"   mxArray* pOut2 = NULL;";
+"";
+"   if(nrhs != 2 || nlhs != 2/*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   bIn1 = mxIsLogicalScalarTrue(prhs[0]);";
+"   bIn2 = mxIsLogicalScalarTrue(prhs[1]);";
+"";
+"   pOut1 = mxCreateLogicalScalar(!bIn1);";
+"   pOut2 = mxCreateLogicalScalar(!bIn2);";
+"";
+"   plhs[0] = pOut1;";
+"   plhs[1] = pOut2;";
+"}"],"mexCreateLogicalScalar.c");
+ilib_mex_build("libmextest", ["createLogicalScalar", "mexCreateLogicalScalar", "cmex"], "mexCreateLogicalScalar.c", [], "", "", "", "");
+exec("loader.sce");
 
 [out1, out2] = createLogicalScalar(%t, %f);
 
-if out1 <> %f then pause end
-if out2 <> %t then pause end
+assert_checkfalse(out1);
+assert_checktrue(out2);
 
index 81d2af2..e70b6d3 100644 (file)
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateNumericArray mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int piDims[3] = {4,3,2};';
-        '   int iDims = 3;';
-        '   mxClassID CLASS = 0;';
-        '   double* pdblType = NULL;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pdblType = mxGetPr(prhs[0]);';
-        '   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateNumericArray.c');
-
-ilib_mex_build('libmextest',['createNumericArray','mexCreateNumericArray','cmex'], 'mexCreateNumericArray.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int piDims[3] = {4,3,2};";
+        "   int iDims = 3;";
+        "   mxClassID CLASS = 0;";
+        "   double* pdblType = NULL;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   pdblType = mxGetPr(prhs[0]);";
+        "   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);";
+        "   plhs[0] = pOut;";
+        "}"],"mexCreateNumericArray.c");
+ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[],"","","","");
+exec("loader.sce");
 ref_int8 = int8(1);
-
 ref_int8(4,3,2) = int8(1);
-
 ref_int8(:) = int8(0);
-
 ref_uint8 = uint8(1);
-
 ref_uint8(4,3,2) = uint8(1);
-
 ref_uint8(:) = uint8(0);
-
 ref_int16 = int16(1);
-
 ref_int16(4,3,2) = int16(1);
-
 ref_int16(:) = int16(0);
-
 ref_uint16 = uint16(1);
-
 ref_uint16(4,3,2) = uint16(1);
-
 ref_uint16(:) = uint16(0);
-
 ref_int32 = int32(1);
-
 ref_int32(4,3,2) = int32(1);
-
 ref_int32(:) = int32(0);
-
 ref_uint32 = uint32(1);
-
 ref_uint32(4,3,2) = uint32(1);
-
 ref_uint32(:) = uint32(0);
-
 ref_int64 = int64(1);
-
 ref_int64(4,3,2) = int64(1);
-
 ref_int64(:) = int64(0);
-
 ref_uint64 = uint64(1);
-
 ref_uint64(4,3,2) = uint64(1);
-
 ref_uint64(:) = uint64(0);
-
 ret8 = createNumericArray(8);
-
 retU8 = createNumericArray(9);
-
 ret16 = createNumericArray(10);
-
 retU16 = createNumericArray(11);
-
 ret32 = createNumericArray(12);
-
 retU32 = createNumericArray(13);
-
 ret64 = createNumericArray(14);
-
 retU64 = createNumericArray(15);
-
index b79373b..443c7f9 100644 (file)
@@ -6,34 +6,33 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateNumericArray mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int piDims[3] = {4,3,2};';
-        '   int iDims = 3;';
-        '   mxClassID CLASS = 0;';
-        '   double* pdblType = NULL;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pdblType = mxGetPr(prhs[0]);';
-        '   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateNumericArray.c');
-ilib_mex_build('libmextest',['createNumericArray','mexCreateNumericArray','cmex'], 'mexCreateNumericArray.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int piDims[3] = {4,3,2};";
+"   int iDims = 3;";
+"   mxClassID CLASS = 0;";
+"   double* pdblType = NULL;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pdblType = mxGetPr(prhs[0]);";
+"   pOut = mxCreateNumericArray(iDims, piDims, (mxClassID)pdblType[0], mxREAL);";
+"   plhs[0] = pOut;";
+"}"],"mexCreateNumericArray.c");
+ilib_mex_build("libmextest",["createNumericArray","mexCreateNumericArray","cmex"], "mexCreateNumericArray.c",[],"","","","");
+exec("loader.sce");
 
 ref_int8 = int8(1);
 ref_int8(4,3,2) = int8(1);
index 1af582a..cb3779a 100644 (file)
@@ -1,52 +1,31 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateString mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pOut = mxCreateString(""Create new String"");';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateString.c');
-
-ilib_mex_build('libmextest',['createString','mexCreateString','cmex'], 'mexCreateString.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   pOut = mxCreateString(""Create new String"");";
+        "   plhs[0] = pOut;";
+        "}"],"mexCreateString.c");
+ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[],"","","","");
+exec("loader.sce");
 ref = "Create new String";
-
 a = createString();
-
-if a <> ref then pause end
-
+assert_checkequal(a, ref);
index a46f872..62d1837 100644 (file)
@@ -6,30 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateString mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pOut = mxCreateString(""Create new String"");';
-        '   plhs[0] = pOut;';
-        '}'],'mexCreateString.c');
-ilib_mex_build('libmextest',['createString','mexCreateString','cmex'], 'mexCreateString.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 0 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pOut = mxCreateString(""Create new String"");";
+"   plhs[0] = pOut;";
+"}"],"mexCreateString.c");
+ilib_mex_build("libmextest",["createString","mexCreateString","cmex"], "mexCreateString.c",[],"","","","");
+exec("loader.sce");
 
 ref = "Create new String";
 a = createString();
-if a <> ref then pause end
+assert_checkequal(a, ref);
index edbe223..92cb308 100644 (file)
@@ -1,48 +1,27 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxCreateStructMatrix and mxCreateStructArray mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {3, 3};';
-       '    char *fields[2];';
-       '    fields[0] = ""f1"";';
-       '    fields[1] = ""f2"";';
-       '    plhs[0] = mxCreateStructArray(2, dims, 2, fields);';
-       '    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);';
-       '}'],'mexcreateStruct.c');
-
-ilib_mex_build('libmextest',['createStruct','mexcreateStruct','cmex'], 'mexcreateStruct.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    int dims[2] = {3, 3};";
+       "    char *fields[2];";
+       "    fields[0] = ""f1"";";
+       "    fields[1] = ""f2"";";
+       "    plhs[0] = mxCreateStructArray(2, dims, 2, fields);";
+       "    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);";
+       "}"],"mexcreateStruct.c");
+ilib_mex_build("libmextest",["createStruct","mexcreateStruct","cmex"], "mexcreateStruct.c",[],"","","","");
+exec("loader.sce");
 [out1, out2] = createStruct();
-
-if size(out1, "*") <> 9 then pause end
-
-if size(out2, "*") <> 4 then pause end
-
+assert_checkequal(size(out1, "*"), 9);
+assert_checkequal(size(out2, "*"), 4);
index dc32f64..e86e590 100644 (file)
@@ -6,28 +6,27 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxCreateStructMatrix and mxCreateStructArray mex functions
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {3, 3};';
-       '    char *fields[2];';
-       '    fields[0] = ""f1"";';
-       '    fields[1] = ""f2"";';
-       '    plhs[0] = mxCreateStructArray(2, dims, 2, fields);';
-       '    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);';
-       '}'],'mexcreateStruct.c');
-ilib_mex_build('libmextest',['createStruct','mexcreateStruct','cmex'], 'mexcreateStruct.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int dims[2] = {3, 3};";
+"    char *fields[2];";
+"    fields[0] = ""f1"";";
+"    fields[1] = ""f2"";";
+"    plhs[0] = mxCreateStructArray(2, dims, 2, fields);";
+"    plhs[1] = mxCreateStructMatrix(2, 2, 2, fields);";
+"}"],"mexcreateStruct.c");
+ilib_mex_build("libmextest",["createStruct","mexcreateStruct","cmex"], "mexcreateStruct.c",[],"","","","");
+exec("loader.sce");
 
 [out1, out2] = createStruct();
 
-if size(out1, "*") <> 9 then pause end
+assert_checkequal(size(out1, "*"), 9);
 
-if size(out2, "*") <> 4 then pause end
\ No newline at end of file
+assert_checkequal(size(out2, "*"), 4);
index 8a62619..8a9cdc7 100644 (file)
@@ -1,52 +1,31 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxDuplicateArray mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pOut = mxDuplicateArray(prhs[0]);';
-        '   plhs[0] = pOut;';
-        '}'],'mexDuplicateArray.c');
-
-ilib_mex_build('libmextest',['duplicateArray','mexDuplicateArray','cmex'], 'mexDuplicateArray.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   pOut = mxDuplicateArray(prhs[0]);";
+        "   plhs[0] = pOut;";
+        "}"],"mexDuplicateArray.c");
+ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[],"","","","");
+exec("loader.sce");
 a = rand(4,3);
-
 b = duplicateArray(a);
-
-if a <> b then pause end
-
+assert_checkequal(a, b);
index fe48399..d8c1b80 100644 (file)
@@ -6,30 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxDuplicateArray mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   pOut = mxDuplicateArray(prhs[0]);';
-        '   plhs[0] = pOut;';
-        '}'],'mexDuplicateArray.c');
-ilib_mex_build('libmextest',['duplicateArray','mexDuplicateArray','cmex'], 'mexDuplicateArray.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   pOut = mxDuplicateArray(prhs[0]);";
+"   plhs[0] = pOut;";
+"}"],"mexDuplicateArray.c");
+ilib_mex_build("libmextest",["duplicateArray","mexDuplicateArray","cmex"], "mexDuplicateArray.c",[],"","","","");
+exec("loader.sce");
 
 a = rand(4,3);
 b = duplicateArray(a);
-if a <> b then pause end
+assert_checkequal(a, b);
index da9e5fb..8e911ea 100644 (file)
@@ -1,42 +1,22 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetChars mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char *chars = mxGetChars(prhs[0]);';
-       '    plhs[0] = mxCreateString(chars);';
-       '}'],'mexgetChars.c');
-
-ilib_mex_build('libmextest',['getChars','mexgetChars','cmex'], 'mexgetChars.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    char *chars = mxGetChars(prhs[0]);";
+       "    plhs[0] = mxCreateString(chars);";
+       "}"],"mexgetChars.c");
+ilib_mex_build("libmextest",["getChars","mexgetChars","cmex"], "mexgetChars.c",[],"","","","");
+exec("loader.sce");
 r = getChars("hello world");
-
-if r <> "hello world" then pause end
-
+assert_checkequal(r, "hello world");
index 328fa51..b9e6144 100644 (file)
@@ -6,21 +6,20 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetChars mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char *chars = mxGetChars(prhs[0]);';
-       '    plhs[0] = mxCreateString(chars);';
-       '}'],'mexgetChars.c');
-ilib_mex_build('libmextest',['getChars','mexgetChars','cmex'], 'mexgetChars.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char *chars = mxGetChars(prhs[0]);";
+"    plhs[0] = mxCreateString(chars);";
+"}"],"mexgetChars.c");
+ilib_mex_build("libmextest",["getChars","mexgetChars","cmex"], "mexgetChars.c",[],"","","","");
+exec("loader.sce");
 
 r = getChars("hello world");
-if r <> "hello world" then pause end
+assert_checkequal(r, "hello world");
index cb0e7a0..d7938d8 100644 (file)
@@ -1,87 +1,69 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetClassID mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {';
-       '        mexPrintf(""cell"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {';
-       '        mexPrintf(""char"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {';
-       '        mexPrintf(""double"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {';
-       '        mexPrintf(""function_handle"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {';
-       '        mexPrintf(""int8"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {';
-       '        mexPrintf(""int16"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {';
-       '        mexPrintf(""int32"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {';
-       '        mexPrintf(""int64"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {';
-       '        mexPrintf(""logical"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {';
-       '        mexPrintf(""single"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {';
-       '        mexPrintf(""struct"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {';
-       '        mexPrintf(""uint8"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {';
-       '        mexPrintf(""uint16"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {';
-       '        mexPrintf(""uint32"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {';
-       '        mexPrintf(""uint64"");';
-       '    }'
-       '}'],'mexgetClassID.c');
-
-ilib_mex_build('libmextest',['printClass','mexgetClassID','cmex'], 'mexgetClassID.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {";
+"        mexPrintf(""cell"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {";
+"        mexPrintf(""char"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {";
+"        mexPrintf(""double"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {";
+"        mexPrintf(""function_handle"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {";
+"        mexPrintf(""int8"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {";
+"        mexPrintf(""int16"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {";
+"        mexPrintf(""int32"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {";
+"        mexPrintf(""int64"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {";
+"        mexPrintf(""logical"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {";
+"        mexPrintf(""single"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {";
+"        mexPrintf(""struct"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {";
+"        mexPrintf(""uint8"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {";
+"        mexPrintf(""uint16"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {";
+"        mexPrintf(""uint32"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {";
+"        mexPrintf(""uint64"");";
+"    }"
+"}"],"mexgetClassID.c");
+ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[],"","","","");
+exec("loader.sce");
 printClass(cell());
 cell
-printClass('s');
+printClass("s");
 char
 printClass(1);
 double
index df92cf3..859c6eb 100644 (file)
@@ -6,68 +6,67 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetClassID mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {';
-       '        mexPrintf(""cell"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {';
-       '        mexPrintf(""char"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {';
-       '        mexPrintf(""double"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {';
-       '        mexPrintf(""function_handle"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {';
-       '        mexPrintf(""int8"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {';
-       '        mexPrintf(""int16"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {';
-       '        mexPrintf(""int32"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {';
-       '        mexPrintf(""int64"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {';
-       '        mexPrintf(""logical"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {';
-       '        mexPrintf(""single"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {';
-       '        mexPrintf(""struct"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {';
-       '        mexPrintf(""uint8"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {';
-       '        mexPrintf(""uint16"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {';
-       '        mexPrintf(""uint32"");';
-       '    }'
-       '    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {';
-       '        mexPrintf(""uint64"");';
-       '    }'
-       '}'],'mexgetClassID.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxGetClassID(prhs[0]) == mxCELL_CLASS) {";
+"        mexPrintf(""cell"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxCHAR_CLASS) {";
+"        mexPrintf(""char"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxDOUBLE_CLASS) {";
+"        mexPrintf(""double"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxFUNCTION_CLASS) {";
+"        mexPrintf(""function_handle"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT8_CLASS) {";
+"        mexPrintf(""int8"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT16_CLASS) {";
+"        mexPrintf(""int16"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT32_CLASS) {";
+"        mexPrintf(""int32"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxINT64_CLASS) {";
+"        mexPrintf(""int64"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxLOGICAL_CLASS) {";
+"        mexPrintf(""logical"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxSINGLE_CLASS) {";
+"        mexPrintf(""single"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxSTRUCT_CLASS) {";
+"        mexPrintf(""struct"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT8_CLASS) {";
+"        mexPrintf(""uint8"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT16_CLASS) {";
+"        mexPrintf(""uint16"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT32_CLASS) {";
+"        mexPrintf(""uint32"");";
+"    }"
+"    if (mxGetClassID(prhs[0]) == mxUINT64_CLASS) {";
+"        mexPrintf(""uint64"");";
+"    }"
+"}"],"mexgetClassID.c");
 
-ilib_mex_build('libmextest',['printClass','mexgetClassID','cmex'], 'mexgetClassID.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["printClass","mexgetClassID","cmex"], "mexgetClassID.c",[],"","","","");
+exec("loader.sce");
 
 printClass(cell());
-printClass('s');
+printClass("s");
 printClass(1);
 printClass(sum);
 printClass(int8(1));
index 180b36f..cdf3263 100644 (file)
@@ -1,43 +1,25 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetClassName mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexPrintf(mxGetClassName(prhs[0]));';
-       '}'],'mexgetClassName.c');
-
-ilib_mex_build('libmextest',['printClassName','mexgetClassName','cmex'], 'mexgetClassName.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexPrintf(mxGetClassName(prhs[0]));";
+"}"],"mexgetClassName.c");
+ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[],"","","","");
+exec("loader.sce");
 printClassName(cell());
 cell
-printClassName('s');
+printClassName("s");
 char
 printClassName(1);
 double
index 0854d14..9f226d9 100644 (file)
@@ -6,24 +6,23 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetClassName mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mexPrintf(mxGetClassName(prhs[0]));';
-       '}'],'mexgetClassName.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mexPrintf(mxGetClassName(prhs[0]));";
+"}"],"mexgetClassName.c");
 
-ilib_mex_build('libmextest',['printClassName','mexgetClassName','cmex'], 'mexgetClassName.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["printClassName","mexgetClassName","cmex"], "mexgetClassName.c",[],"","","","");
+exec("loader.sce");
 
 printClassName(cell());
-printClassName('s');
+printClassName("s");
 printClassName(1);
 printClassName(sum);
 printClassName(int8(1));
index 529efed..05b25a7 100644 (file)
@@ -1,51 +1,28 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetDimensions mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int ndim = mxGetNumberOfDimensions(prhs[0]);';
-       '    int *dims = mxGetDimensions(prhs[0]);';
-       '    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);';
-       '    mxSetPr(ptr, dims);';
-       '    plhs[0] = ptr;';
-       '}'],'mexgetDimensions.c');
-
-ilib_mex_build('libmextest',['getDimensions','mexgetDimensions','cmex'], 'mexgetDimensions.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
-if getDimensions([1]) <> [1 1] then pause end
-
-if getDimensions([1 1 1]) <> [1 3] then pause end
-
-if getDimensions([1;1;1]) <> [3 1] then pause end
-
-if getDimensions([1 1;2 2;3 3]) <> [3 2] then pause end
-
-if getDimensions(zeros(4, 2, 3)) <> [4 2 3] then pause end
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    int ndim = mxGetNumberOfDimensions(prhs[0]);";
+       "    int *dims = mxGetDimensions(prhs[0]);";
+       "    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);";
+       "    mxSetPr(ptr, dims);";
+       "    plhs[0] = ptr;";
+       "}"],"mexgetDimensions.c");
+ilib_mex_build("libmextest",["getDimensions","mexgetDimensions","cmex"], "mexgetDimensions.c",[],"","","","");
+exec("loader.sce");
+assert_checkequal(getDimensions([1]), int32([1 1]));
+assert_checkequal(getDimensions([1 1 1]), int32([1 3]));
+assert_checkequal(getDimensions([1;1;1]), int32([3 1]));
+assert_checkequal(getDimensions([1 1;2 2;3 3]), int32([3 2]));
+assert_checkequal(getDimensions(zeros(4, 2, 3)), int32([4 2 3]));
index 3a21b08..f1f62b0 100644 (file)
@@ -6,27 +6,26 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetDimensions mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int ndim = mxGetNumberOfDimensions(prhs[0]);';
-       '    int *dims = mxGetDimensions(prhs[0]);';
-       '    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);';
-       '    mxSetPr(ptr, dims);';
-       '    plhs[0] = ptr;';
-       '}'],'mexgetDimensions.c');
-ilib_mex_build('libmextest',['getDimensions','mexgetDimensions','cmex'], 'mexgetDimensions.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int ndim = mxGetNumberOfDimensions(prhs[0]);";
+"    int *dims = mxGetDimensions(prhs[0]);";
+"    mxArray *ptr = mxCreateNumericMatrix(1, ndim, mxINT32_CLASS, mxREAL);";
+"    mxSetPr(ptr, dims);";
+"    plhs[0] = ptr;";
+"}"],"mexgetDimensions.c");
+ilib_mex_build("libmextest",["getDimensions","mexgetDimensions","cmex"], "mexgetDimensions.c",[],"","","","");
+exec("loader.sce");
 
-if getDimensions([1]) <> [1 1] then pause end
-if getDimensions([1 1 1]) <> [1 3] then pause end
-if getDimensions([1;1;1]) <> [3 1] then pause end
-if getDimensions([1 1;2 2;3 3]) <> [3 2] then pause end
-if getDimensions(zeros(4, 2, 3)) <> [4 2 3] then pause end
+assert_checkequal(getDimensions([1]), int32([1 1]));
+assert_checkequal(getDimensions([1 1 1]), int32([1 3]));
+assert_checkequal(getDimensions([1;1;1]), int32([3 1]));
+assert_checkequal(getDimensions([1 1;2 2;3 3]), int32([3 2]));
+assert_checkequal(getDimensions(zeros(4, 2, 3)), int32([4 2 3]));
index f304c40..eac1125 100644 (file)
@@ -1,63 +1,45 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetElementSize mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       '#include ""wchar.h""';
-       'void check(mxArray *ptr, int size)';
-       '{';
-       '    if (mxGetElementSize(ptr) == size)';
-       '    {'
-       '        mexPrintf(""T"");';
-       '    }'
-       '    else'
-       '    {'
-       '        mexPrintf(""F"");';
-       '    }'
-       '}';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));';
-       '    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));';
-       '    check(mxCreateString(""foo""), sizeof(wchar_t *));';
-       '    check(mxCreateDoubleScalar(1), sizeof(double));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));';
-       '    check(mxCreateLogicalScalar(0), sizeof(int));';
-       '}'],'mexgetElementSize.c');
-
-ilib_mex_build('libmextest',['getElementSize','mexgetElementSize','cmex'], 'mexgetElementSize.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "#include ""wchar.h""";
+       "void check(mxArray *ptr, int size)";
+       "{";
+       "    if (mxGetElementSize(ptr) == size)";
+       "    {"
+       "        mexPrintf(""T"");";
+       "    }"
+       "    else"
+       "    {"
+       "        mexPrintf(""F"");";
+       "    }"
+       "}";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));";
+       "    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));";
+       "    check(mxCreateString(""foo""), sizeof(wchar_t *));";
+       "    check(mxCreateDoubleScalar(1), sizeof(double));";
+       "    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));";
+       "    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));";
+       "    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));";
+       "    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));";
+       "    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));";
+       "    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));";
+       "    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));";
+       "    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));";
+       "    check(mxCreateLogicalScalar(0), sizeof(int));";
+       "}"],"mexgetElementSize.c");
+ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[],"","","","");
+exec("loader.sce");
 getElementSize();
 TTTTTTTTTTTTT
index ab26200..fc77a6e 100644 (file)
@@ -6,45 +6,44 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetElementSize mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       '#include ""wchar.h""';
-       'void check(mxArray *ptr, int size)';
-       '{';
-       '    if (mxGetElementSize(ptr) == size)';
-       '    {'
-       '        mexPrintf(""T"");';
-       '    }'
-       '    else'
-       '    {'
-       '        mexPrintf(""F"");';
-       '    }'
-       '}';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));';
-       '    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));';
-       '    check(mxCreateString(""foo""), sizeof(wchar_t *));';
-       '    check(mxCreateDoubleScalar(1), sizeof(double));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));';
-       '    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));';
-       '    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));';
-       '    check(mxCreateLogicalScalar(0), sizeof(int));';
-       '}'],'mexgetElementSize.c');
+mputl(["#include ""mex.h""";
+"#include ""wchar.h""";
+"void check(mxArray *ptr, int size)";
+"{";
+"    if (mxGetElementSize(ptr) == size)";
+"    {"
+"        mexPrintf(""T"");";
+"    }"
+"    else"
+"    {"
+"        mexPrintf(""F"");";
+"    }"
+"}";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    check(mxCreateCellMatrix(2, 2), sizeof(mxArray *));";
+"    check(mxCreateStructMatrix(2, 2, 0, NULL), sizeof(mxArray *));";
+"    check(mxCreateString(""foo""), sizeof(wchar_t *));";
+"    check(mxCreateDoubleScalar(1), sizeof(double));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT8_CLASS, mxREAL), sizeof(char));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT16_CLASS, mxREAL), sizeof(short));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT32_CLASS, mxREAL), sizeof(int));";
+"    check(mxCreateNumericMatrix(2, 2, mxINT64_CLASS, mxREAL), sizeof(long long));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT8_CLASS, mxREAL), sizeof(unsigned char));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT16_CLASS, mxREAL), sizeof(unsigned short));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT32_CLASS, mxREAL), sizeof(unsigned int));";
+"    check(mxCreateNumericMatrix(2, 2, mxUINT64_CLASS, mxREAL), sizeof(unsigned long long));";
+"    check(mxCreateLogicalScalar(0), sizeof(int));";
+"}"],"mexgetElementSize.c");
 
 
-ilib_mex_build('libmextest',['getElementSize','mexgetElementSize','cmex'], 'mexgetElementSize.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["getElementSize","mexgetElementSize","cmex"], "mexgetElementSize.c",[],"","","","");
+exec("loader.sce");
 
 getElementSize();
index d8daadf..37900d9 100644 (file)
@@ -1,43 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetEps mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblEps = mxGetEps();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblEps);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetEps.c');
-
-ilib_mex_build('libmextest',['getEps','mexgetEps','cmex'], 'mexgetEps.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double dblEps = mxGetEps();";
+       "    mxArray* pOut = mxCreateDoubleScalar(dblEps);";
+       "    plhs[0] = pOut;";
+       "}"],"mexgetEps.c");
+ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[],"","","","");
+exec("loader.sce");
 a = getEps();
-
-if a <> %eps then pause end
-
+assert_checkequal(a, %eps);
index 80e0ffd..f348dfb 100644 (file)
@@ -6,22 +6,21 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetEps mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblEps = mxGetEps();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblEps);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetEps.c');
-ilib_mex_build('libmextest',['getEps','mexgetEps','cmex'], 'mexgetEps.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double dblEps = mxGetEps();";
+"    mxArray* pOut = mxCreateDoubleScalar(dblEps);";
+"    plhs[0] = pOut;";
+"}"],"mexgetEps.c");
+ilib_mex_build("libmextest",["getEps","mexgetEps","cmex"], "mexgetEps.c",[],"","","","");
+exec("loader.sce");
 
 a = getEps();
-if a <> %eps then pause end
+assert_checkequal(a, %eps);
index 37d3145..3620a5e 100644 (file)
@@ -1,55 +1,29 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetField mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *value = mxGetField(prhs[0], 0, ""a"");';
-       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
-       '    plhs[0] = value;';
-       '}'],'mexgetField.c');
-
-ilib_mex_build('libmextest',['getField','mexgetField','cmex'], 'mexgetField.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxArray *value = mxGetField(prhs[0], 0, ""a"");";
+       "    if (value == NULL) value = mxCreateDoubleScalar(-1);";
+       "    plhs[0] = value;";
+       "}"],"mexgetField.c");
+ilib_mex_build("libmextest",["getField","mexgetField","cmex"], "mexgetField.c",[],"","","","");
+exec("loader.sce");
 c = struct("a", 5, "b", 2);
-
 r = getField(c);
-
-if r <> 5 then pause end
-
+assert_checkequal(r, 5);
 c = struct("b", 32);
-
 r = getField(c);
-
-if r <> -1 then pause end
-
+assert_checkequal(r, -1);
 r = getField(1);
-
-if r <> -1 then pause end
-
+assert_checkequal(r, -1);
index 2222e93..543b6b1 100644 (file)
@@ -6,30 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetField mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *value = mxGetField(prhs[0], 0, ""a"");';
-       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
-       '    plhs[0] = value;';
-       '}'],'mexgetField.c');
-ilib_mex_build('libmextest',['getField','mexgetField','cmex'], 'mexgetField.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *value = mxGetField(prhs[0], 0, ""a"");";
+"    if (value == NULL) value = mxCreateDoubleScalar(-1);";
+"    plhs[0] = value;";
+"}"],"mexgetField.c");
+ilib_mex_build("libmextest",["getField","mexgetField","cmex"], "mexgetField.c",[],"","","","");
+exec("loader.sce");
 
 c = struct("a", 5, "b", 2);
 r = getField(c);
-if r <> 5 then pause end
+assert_checkequal(r, 5);
 
 c = struct("b", 32);
 r = getField(c);
-if r <> -1 then pause end
+assert_checkequal(r, -1);
 
 r = getField(1);
-if r <> -1 then pause end
+assert_checkequal(r, -1);
index 8443dcc..7a069ca 100644 (file)
@@ -1,55 +1,29 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetFieldByNumber mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);';
-       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
-       '    plhs[0] = value;';
-       '}'],'mexgetFieldByNumber.c');
-
-ilib_mex_build('libmextest',['getFieldByNumber','mexgetFieldByNumber','cmex'], 'mexgetFieldByNumber.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);";
+       "    if (value == NULL) value = mxCreateDoubleScalar(-1);";
+       "    plhs[0] = value;";
+       "}"],"mexgetFieldByNumber.c");
+ilib_mex_build("libmextest",["getFieldByNumber","mexgetFieldByNumber","cmex"], "mexgetFieldByNumber.c",[],"","","","");
+exec("loader.sce");
 c = struct("a", 5, "b", 2);
-
 r = getFieldByNumber(c);
-
-if r <> 2 then pause end
-
+assert_checkequal(r, 2);
 c = struct("b", 32);
-
 r = getFieldByNumber(c);
-
-if r <> -1 then pause end
-
+assert_checkequal(r, -1);
 r = getFieldByNumber(1);
-
-if r <> -1 then pause end
-
+assert_checkequal(r, -1);
index c0b9cb1..4ac6c39 100644 (file)
@@ -6,30 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetFieldByNumber mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);';
-       '    if (value == NULL) value = mxCreateDoubleScalar(-1);';
-       '    plhs[0] = value;';
-       '}'],'mexgetFieldByNumber.c');
-ilib_mex_build('libmextest',['getFieldByNumber','mexgetFieldByNumber','cmex'], 'mexgetFieldByNumber.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *value = mxGetFieldByNumber(prhs[0], 0, 1);";
+"    if (value == NULL) value = mxCreateDoubleScalar(-1);";
+"    plhs[0] = value;";
+"}"],"mexgetFieldByNumber.c");
+ilib_mex_build("libmextest",["getFieldByNumber","mexgetFieldByNumber","cmex"], "mexgetFieldByNumber.c",[],"","","","");
+exec("loader.sce");
 
 c = struct("a", 5, "b", 2);
 r = getFieldByNumber(c);
-if r <> 2 then pause end
+assert_checkequal(r, 2);
 
 c = struct("b", 32);
 r = getFieldByNumber(c);
-if r <> -1 then pause end
+assert_checkequal(r, -1);
 
 r = getFieldByNumber(1);
-if r <> -1 then pause end
+assert_checkequal(r, -1);
index 38bf400..0734214 100644 (file)
@@ -1,47 +1,25 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetFieldNameByNumber mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int fieldnum = mxGetScalar(prhs[1]);';
-       '    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);';
-       '    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");';
-       '}'],'mexGetFieldNameByNumber.c');
-
-ilib_mex_build('libmextest',['getFieldNameByNumber','mexGetFieldNameByNumber','cmex'], 'mexGetFieldNameByNumber.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    int fieldnum = mxGetScalar(prhs[1]);";
+       "    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);";
+       "    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");";
+       "}"],"mexGetFieldNameByNumber.c");
+ilib_mex_build("libmextest",["getFieldNameByNumber","mexGetFieldNameByNumber","cmex"], "mexGetFieldNameByNumber.c",[],"","","","");
+exec("loader.sce");
 s = struct("a", 1, "b", 2);
-
-if getFieldNameByNumber(s, 0) <> "a" then pause end
-
-if getFieldNameByNumber(s, 1) <> "b" then pause end
-
-if getFieldNameByNumber(s, 2) <> "" then pause end
-
+assert_checkequal(getFieldNameByNumber(s, 0), "a");
+assert_checkequal(getFieldNameByNumber(s, 1), "b");
+assert_checkequal(getFieldNameByNumber(s, 2), "");
index a4ca10e..b6d355e 100644 (file)
@@ -6,24 +6,23 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetFieldNameByNumber mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int fieldnum = mxGetScalar(prhs[1]);';
-       '    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);';
-       '    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");';
-       '}'],'mexGetFieldNameByNumber.c');
-ilib_mex_build('libmextest',['getFieldNameByNumber','mexGetFieldNameByNumber','cmex'], 'mexGetFieldNameByNumber.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int fieldnum = mxGetScalar(prhs[1]);";
+"    char *fieldname = mxGetFieldNameByNumber(prhs[0], fieldnum);";
+"    plhs[0] = mxCreateString(fieldname != NULL ? fieldname : """");";
+"}"],"mexGetFieldNameByNumber.c");
+ilib_mex_build("libmextest",["getFieldNameByNumber","mexGetFieldNameByNumber","cmex"], "mexGetFieldNameByNumber.c",[],"","","","");
+exec("loader.sce");
 
 s = struct("a", 1, "b", 2);
-if getFieldNameByNumber(s, 0) <> "a" then pause end
-if getFieldNameByNumber(s, 1) <> "b" then pause end
-if getFieldNameByNumber(s, 2) <> "" then pause end
+assert_checkequal(getFieldNameByNumber(s, 0), "a");
+assert_checkequal(getFieldNameByNumber(s, 1), "b");
+assert_checkequal(getFieldNameByNumber(s, 2), "");
index 7efce79..375dacd 100644 (file)
@@ -1,43 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetInf mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblInf = mxGetInf();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblInf);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetInf.c');
-
-ilib_mex_build('libmextest',['getInf','mexgetInf','cmex'], 'mexgetInf.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double dblInf = mxGetInf();";
+       "    mxArray* pOut = mxCreateDoubleScalar(dblInf);";
+       "    plhs[0] = pOut;";
+       "}"],"mexgetInf.c");
+ilib_mex_build("libmextest",["getInf","mexgetInf","cmex"], "mexgetInf.c",[],"","","","");
+exec("loader.sce");
 a = getInf();
-
-if a <> %inf then pause end
-
+assert_checkequal(a, %inf);
index af6a5d6..b0f6245 100644 (file)
@@ -6,22 +6,21 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetInf mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblInf = mxGetInf();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblInf);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetInf.c');
-ilib_mex_build('libmextest',['getInf','mexgetInf','cmex'], 'mexgetInf.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double dblInf = mxGetInf();";
+"    mxArray* pOut = mxCreateDoubleScalar(dblInf);";
+"    plhs[0] = pOut;";
+"}"],"mexgetInf.c");
+ilib_mex_build("libmextest",["getInf","mexgetInf","cmex"], "mexgetInf.c",[],"","","","");
+exec("loader.sce");
 
 a = getInf();
-if a <> %inf then pause end
+assert_checkequal(a, %inf);
index 7ae3874..6f969da 100644 (file)
@@ -1,45 +1,24 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetLogicals mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxLogical *logicals = mxGetLogicals(prhs[0]);';
-       '    plhs[0] = mxCreateLogicalScalar(logicals[0]);';
-       '    plhs[1] = mxCreateLogicalScalar(logicals[1]);';
-       '}'],'mexgetLogicals.c');
-
-ilib_mex_build('libmextest',['getLogicals','mexgetLogicals','cmex'], 'mexgetLogicals.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxLogical *logicals = mxGetLogicals(prhs[0]);";
+       "    plhs[0] = mxCreateLogicalScalar(logicals[0]);";
+       "    plhs[1] = mxCreateLogicalScalar(logicals[1]);";
+       "}"],"mexgetLogicals.c");
+ilib_mex_build("libmextest",["getLogicals","mexgetLogicals","cmex"], "mexgetLogicals.c",[],"","","","");
+exec("loader.sce");
 [out1, out2] = getLogicals([%t %f]);
-
-if out1 <> %t then pause end
-
-if out2 <> %f then pause end
-
+assert_checktrue(out1);
+assert_checkfalse(out2);
index 725df4d..1185c56 100644 (file)
@@ -6,23 +6,22 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetLogicals mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxLogical *logicals = mxGetLogicals(prhs[0]);';
-       '    plhs[0] = mxCreateLogicalScalar(logicals[0]);';
-       '    plhs[1] = mxCreateLogicalScalar(logicals[1]);';
-       '}'],'mexgetLogicals.c');
-ilib_mex_build('libmextest',['getLogicals','mexgetLogicals','cmex'], 'mexgetLogicals.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxLogical *logicals = mxGetLogicals(prhs[0]);";
+"    plhs[0] = mxCreateLogicalScalar(logicals[0]);";
+"    plhs[1] = mxCreateLogicalScalar(logicals[1]);";
+"}"],"mexgetLogicals.c");
+ilib_mex_build("libmextest",["getLogicals","mexgetLogicals","cmex"], "mexgetLogicals.c",[],"","","","");
+exec("loader.sce");
 
 [out1, out2] = getLogicals([%t %f]);
-if out1 <> %t then pause end
-if out2 <> %f then pause end
+assert_checktrue(out1);
+assert_checkfalse(out2);
index 130a4a1..01bbcfe 100644 (file)
@@ -1,43 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetNaN mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblNaN = mxGetNaN();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblNaN);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetNaN.c');
-
-ilib_mex_build('libmextest',['getNaN','mexgetNaN','cmex'], 'mexgetNaN.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double dblNaN = mxGetNaN();";
+       "    mxArray* pOut = mxCreateDoubleScalar(dblNaN);";
+       "    plhs[0] = pOut;";
+       "}"],"mexgetNaN.c");
+ilib_mex_build("libmextest",["getNaN","mexgetNaN","cmex"], "mexgetNaN.c",[],"","","","");
+exec("loader.sce");
 a = getNaN();
-
-if isnan(a) <> %t then pause end
-
+assert_checktrue(isnan(a));
index e24f0af..1f1281d 100644 (file)
@@ -6,22 +6,21 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetNaN mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double dblNaN = mxGetNaN();';
-       '    mxArray* pOut = mxCreateDoubleScalar(dblNaN);';
-       '    plhs[0] = pOut;';
-       '}'],'mexgetNaN.c');
-ilib_mex_build('libmextest',['getNaN','mexgetNaN','cmex'], 'mexgetNaN.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double dblNaN = mxGetNaN();";
+"    mxArray* pOut = mxCreateDoubleScalar(dblNaN);";
+"    plhs[0] = pOut;";
+"}"],"mexgetNaN.c");
+ilib_mex_build("libmextest",["getNaN","mexgetNaN","cmex"], "mexgetNaN.c",[],"","","","");
+exec("loader.sce");
 
 a = getNaN();
-if isnan(a) <> %t then pause end
+assert_checktrue(isnan(a));
index e260a6f..9f5017a 100644 (file)
@@ -1,53 +1,32 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetNumberOfDimensions mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int iDims = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number of input argument"");';
-        '   }';
-        '';
-        '   iDims = mxGetNumberOfDimensions(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar((double)iDims);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetNumberOfDimensions.c');
-
-ilib_mex_build('libmextest',['getDims','mexGetNumberOfDimensions','cmex'], 'mexGetNumberOfDimensions.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int iDims = 0;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number of input argument"");";
+        "   }";
+        "";
+        "   iDims = mxGetNumberOfDimensions(prhs[0]);";
+        "   pOut = mxCreateDoubleScalar((double)iDims);";
+        "   plhs[0] = pOut;";
+        "}"],"mexGetNumberOfDimensions.c");
+ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[],"","","","");
+exec("loader.sce");
 a = ones(5,4,3,2);
-
 iDims = getDims(a);
-
-if iDims <> 4 then pause end
-
+assert_checkequal(iDims, 4);
index d60c151..f2351b2 100644 (file)
@@ -6,33 +6,32 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetNumberOfDimensions mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int iDims = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number of input argument"");';
-        '   }';
-        '';
-        '   iDims = mxGetNumberOfDimensions(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar((double)iDims);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetNumberOfDimensions.c');
-ilib_mex_build('libmextest',['getDims','mexGetNumberOfDimensions','cmex'], 'mexGetNumberOfDimensions.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int iDims = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1)";
+"   {";
+"       mexErrMsgTxt(""Wrong number of input argument"");";
+"   }";
+"";
+"   iDims = mxGetNumberOfDimensions(prhs[0]);";
+"   pOut = mxCreateDoubleScalar((double)iDims);";
+"   plhs[0] = pOut;";
+"}"],"mexGetNumberOfDimensions.c");
+ilib_mex_build("libmextest",["getDims","mexGetNumberOfDimensions","cmex"], "mexGetNumberOfDimensions.c",[],"","","","");
+exec("loader.sce");
 
 a = ones(5,4,3,2);
 iDims = getDims(a);
-if iDims <> 4 then pause end
+assert_checkequal(iDims, 4);
 
 
index 7d0effb..eff7cac 100644 (file)
@@ -1,71 +1,41 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetNumberOfElements mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int iSize = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number of input argument"");';
-        '   }';
-        '';
-        '   iSize = mxGetNumberOfElements(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar((double)iSize);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetNumberOfElements.c');
-
-ilib_mex_build('libmextest',['getNumberOfElements','mexGetNumberOfElements','cmex'], 'mexGetNumberOfElements.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int iSize = 0;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number of input argument"");";
+        "   }";
+        "";
+        "   iSize = mxGetNumberOfElements(prhs[0]);";
+        "   pOut = mxCreateDoubleScalar((double)iSize);";
+        "   plhs[0] = pOut;";
+        "}"],"mexGetNumberOfElements.c");
+ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[],"","","","");
+exec("loader.sce");
 a = ones(1);
-
 var = getNumberOfElements(a);
-
-if var <> size(a, "*") then pause end
-
+assert_checkequal(var, size(a, "*"));
 a = ones(1, 2);
-
 var = getNumberOfElements(a);
-
-if var <> size(a, "*") then pause end
-
+assert_checkequal(var, size(a, "*"));
 a = ones(1, 2, 3);
-
 var = getNumberOfElements(a);
-
-if var <> size(a, "*") then pause end
-
+assert_checkequal(var, size(a, "*"));
 a = ones(1, 2, 3, 4);
-
 var = getNumberOfElements(a);
-
-if var <> size(a, "*") then pause end
-
+assert_checkequal(var, size(a, "*"));
index 592aa60..1287ee8 100644 (file)
@@ -6,44 +6,43 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetNumberOfElements mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int iSize = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number of input argument"");';
-        '   }';
-        '';
-        '   iSize = mxGetNumberOfElements(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar((double)iSize);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetNumberOfElements.c');
-ilib_mex_build('libmextest',['getNumberOfElements','mexGetNumberOfElements','cmex'], 'mexGetNumberOfElements.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int iSize = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1)";
+"   {";
+"       mexErrMsgTxt(""Wrong number of input argument"");";
+"   }";
+"";
+"   iSize = mxGetNumberOfElements(prhs[0]);";
+"   pOut = mxCreateDoubleScalar((double)iSize);";
+"   plhs[0] = pOut;";
+"}"],"mexGetNumberOfElements.c");
+ilib_mex_build("libmextest",["getNumberOfElements","mexGetNumberOfElements","cmex"], "mexGetNumberOfElements.c",[],"","","","");
+exec("loader.sce");
 
 a = ones(1);
 var = getNumberOfElements(a);
-if var <> size(a, "*") then pause end
+assert_checkequal(var, size(a, "*"));
 
 a = ones(1, 2);
 var = getNumberOfElements(a);
-if var <> size(a, "*") then pause end
+assert_checkequal(var, size(a, "*"));
 
 a = ones(1, 2, 3);
 var = getNumberOfElements(a);
-if var <> size(a, "*") then pause end
+assert_checkequal(var, size(a, "*"));
 
 a = ones(1, 2, 3, 4);
 var = getNumberOfElements(a);
-if var <> size(a, "*") then pause end
+assert_checkequal(var, size(a, "*"));
 
index cbefee2..477a597 100644 (file)
@@ -1,60 +1,31 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetNumberOfFields mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int num = mxGetNumberOfFields(prhs[0]);';
-       '    plhs[0] = mxCreateDoubleScalar(num);';
-       '}'],'mexgetNumberOfFields.c');
-
-ilib_mex_build('libmextest',['getNumberOfFields','mexgetNumberOfFields','cmex'], 'mexgetNumberOfFields.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    int num = mxGetNumberOfFields(prhs[0]);";
+       "    plhs[0] = mxCreateDoubleScalar(num);";
+       "}"],"mexgetNumberOfFields.c");
+ilib_mex_build("libmextest",["getNumberOfFields","mexgetNumberOfFields","cmex"], "mexgetNumberOfFields.c",[],"","","","");
+exec("loader.sce");
 c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
-
 r = getNumberOfFields(c);
-
-if r <> 4 then pause end
-
+assert_checkequal(r, 4);
 c = struct("a", 5, "b", 3);
-
 r = getNumberOfFields(c);
-
-if r <> 2 then pause end
-
+assert_checkequal(r, 2);
 c = struct("b", 32);
-
 r = getNumberOfFields(c);
-
-if r <> 1 then pause end
-
+assert_checkequal(r, 1);
 r = getNumberOfFields("not_a_struct");
-
-if r <> 0 then pause end
-
+assert_checkequal(r, 0);
index bb50ca0..d9988ee 100644 (file)
@@ -6,33 +6,32 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetNumberOfFields mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int num = mxGetNumberOfFields(prhs[0]);';
-       '    plhs[0] = mxCreateDoubleScalar(num);';
-       '}'],'mexgetNumberOfFields.c');
-ilib_mex_build('libmextest',['getNumberOfFields','mexgetNumberOfFields','cmex'], 'mexgetNumberOfFields.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int num = mxGetNumberOfFields(prhs[0]);";
+"    plhs[0] = mxCreateDoubleScalar(num);";
+"}"],"mexgetNumberOfFields.c");
+ilib_mex_build("libmextest",["getNumberOfFields","mexgetNumberOfFields","cmex"], "mexgetNumberOfFields.c",[],"","","","");
+exec("loader.sce");
 
 c = struct("a", 5, "b", 3, "e", 1, "another key", "hello");
 r = getNumberOfFields(c);
-if r <> 4 then pause end
+assert_checkequal(r, 4);
 
 c = struct("a", 5, "b", 3);
 r = getNumberOfFields(c);
-if r <> 2 then pause end
+assert_checkequal(r, 2);
 
 c = struct("b", 32);
 r = getNumberOfFields(c);
-if r <> 1 then pause end
+assert_checkequal(r, 1);
 
 r = getNumberOfFields("not_a_struct");
-if r <> 0 then pause end
+assert_checkequal(r, 0);
index 774f394..0e32a5e 100644 (file)
@@ -1,68 +1,40 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetScalar mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   double dblScalar = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   dblScalar = mxGetScalar(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar(dblScalar);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetScalar.c');
-
-ilib_mex_build('libmextest',['getScalar','mexGetScalar','cmex'], 'mexGetScalar.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   double dblScalar = 0;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   dblScalar = mxGetScalar(prhs[0]);";
+        "   pOut = mxCreateDoubleScalar(dblScalar);";
+        "   plhs[0] = pOut;";
+        "}"],"mexGetScalar.c");
+ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[],"","","","");
+exec("loader.sce");
 a = 1:10;
-
-if getScalar(a) <> 1 then pause end
-
-if getScalar(int8(a)) <> 1 then pause end
-
-if getScalar(uint8(a)) <> 1 then pause end
-
-if getScalar(int16(a)) <> 1 then pause end
-
-if getScalar(uint16(a)) <> 1 then pause end
-
-if getScalar(int32(a)) <> 1 then pause end
-
-if getScalar(uint32(a)) <> 1 then pause end
-
-if getScalar(int64(a)) <> 1 then pause end
-
-if getScalar(uint64(a)) <> 1 then pause end
-
+assert_checkequal(getScalar(a), 1);
+assert_checkequal(getScalar(int8(a)), 1);
+assert_checkequal(getScalar(uint8(a)), 1);
+assert_checkequal(getScalar(int16(a)), 1);
+assert_checkequal(getScalar(uint16(a)), 1);
+assert_checkequal(getScalar(int32(a)), 1);
+assert_checkequal(getScalar(uint32(a)), 1);
+assert_checkequal(getScalar(int64(a)), 1);
+assert_checkequal(getScalar(uint64(a)), 1);
index adbe826..6d17234 100644 (file)
@@ -6,40 +6,39 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetScalar mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   double dblScalar = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   dblScalar = mxGetScalar(prhs[0]);';
-        '   pOut = mxCreateDoubleScalar(dblScalar);';
-        '   plhs[0] = pOut;';
-        '}'],'mexGetScalar.c');
-ilib_mex_build('libmextest',['getScalar','mexGetScalar','cmex'], 'mexGetScalar.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   double dblScalar = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   dblScalar = mxGetScalar(prhs[0]);";
+"   pOut = mxCreateDoubleScalar(dblScalar);";
+"   plhs[0] = pOut;";
+"}"],"mexGetScalar.c");
+ilib_mex_build("libmextest",["getScalar","mexGetScalar","cmex"], "mexGetScalar.c",[],"","","","");
+exec("loader.sce");
 
 a = 1:10;
-if getScalar(a) <> 1 then pause end
-if getScalar(int8(a)) <> 1 then pause end
-if getScalar(uint8(a)) <> 1 then pause end
-if getScalar(int16(a)) <> 1 then pause end
-if getScalar(uint16(a)) <> 1 then pause end
-if getScalar(int32(a)) <> 1 then pause end
-if getScalar(uint32(a)) <> 1 then pause end
-if getScalar(int64(a)) <> 1 then pause end
-if getScalar(uint64(a)) <> 1 then pause end
+assert_checkequal(getScalar(a), 1);
+assert_checkequal(getScalar(int8(a)), 1);
+assert_checkequal(getScalar(uint8(a)), 1);
+assert_checkequal(getScalar(int16(a)), 1);
+assert_checkequal(getScalar(uint16(a)), 1);
+assert_checkequal(getScalar(int32(a)), 1);
+assert_checkequal(getScalar(uint32(a)), 1);
+assert_checkequal(getScalar(int64(a)), 1);
+assert_checkequal(getScalar(uint64(a)), 1);
 
index 25d144a..ec70881 100644 (file)
@@ -1,79 +1,41 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetData and mxSetData mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    void *data = mxGetData(prhs[0]);';
-       '    mxSetData(prhs[0], data);';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexGetSetData.c');
-
-ilib_mex_build('libmextest',['getSetData','mexGetSetData','cmex'], 'mexGetSetData.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    void *data = mxGetData(prhs[0]);";
+       "    mxSetData(prhs[0], data);";
+       "    plhs[0] = prhs[0];";
+       "}"],"mexGetSetData.c");
+ilib_mex_build("libmextest",["getSetData","mexGetSetData","cmex"], "mexGetSetData.c",[],"","","","");
+exec("loader.sce");
 r = getSetData(double(1));
-
-if r(1) <> 1 then pause end
-
+assert_checkequal(r(1), 1);
 r = getSetData(int8(2));
-
-if r(1) <> 2 then pause end
-
+assert_checkequal(r(1), int8(2));
 r = getSetData(int16(3));
-
-if r(1) <> 3 then pause end
-
+assert_checkequal(r(1), int16(3));
 r = getSetData(int32(4));
-
-if r(1) <> 4 then pause end
-
+assert_checkequal(r(1), int32(4));
 r = getSetData(int64(5));
-
-if r(1) <> 5 then pause end
-
+assert_checkequal(r(1), int64(5));
 r = getSetData(uint8(6));
-
-if r(1) <> 6 then pause end
-
+assert_checkequal(r(1), uint8(6));
 r = getSetData(uint16(7));
-
-if r(1) <> 7 then pause end
-
+assert_checkequal(r(1), uint16(7));
 r = getSetData(uint32(8));
-
-if r(1) <> 8 then pause end
-
+assert_checkequal(r(1), uint32(8));
 r = getSetData(uint64(9));
-
-if r(1) <> 9 then pause end
-
+assert_checkequal(r(1), uint64(9));
 r = getSetData(%t);
-
-if r(1) <> %t then pause end
-
+assert_checktrue(r(1));
index 7380197..c69aa77 100644 (file)
@@ -6,40 +6,39 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetData and mxSetData mex functions
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    void *data = mxGetData(prhs[0]);';
-       '    mxSetData(prhs[0], data);';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexGetSetData.c');
-ilib_mex_build('libmextest',['getSetData','mexGetSetData','cmex'], 'mexGetSetData.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    void *data = mxGetData(prhs[0]);";
+"    mxSetData(prhs[0], data);";
+"    plhs[0] = prhs[0];";
+"}"],"mexGetSetData.c");
+ilib_mex_build("libmextest",["getSetData","mexGetSetData","cmex"], "mexGetSetData.c",[],"","","","");
+exec("loader.sce");
 
 r = getSetData(double(1));
-if r(1) <> 1 then pause end
+assert_checkequal(r(1), 1);
 r = getSetData(int8(2));
-if r(1) <> 2 then pause end
+assert_checkequal(r(1), int8(2));
 r = getSetData(int16(3));
-if r(1) <> 3 then pause end
+assert_checkequal(r(1), int16(3));
 r = getSetData(int32(4));
-if r(1) <> 4 then pause end
+assert_checkequal(r(1), int32(4));
 r = getSetData(int64(5));
-if r(1) <> 5 then pause end
+assert_checkequal(r(1), int64(5));
 r = getSetData(uint8(6));
-if r(1) <> 6 then pause end
+assert_checkequal(r(1), uint8(6));
 r = getSetData(uint16(7));
-if r(1) <> 7 then pause end
+assert_checkequal(r(1), uint16(7));
 r = getSetData(uint32(8));
-if r(1) <> 8 then pause end
+assert_checkequal(r(1), uint32(8));
 r = getSetData(uint64(9));
-if r(1) <> 9 then pause end
+assert_checkequal(r(1), uint64(9));
 r = getSetData(%t);
-if r(1) <> %t then pause end
\ No newline at end of file
+assert_checktrue(r(1));
index f1a0232..eac15bd 100644 (file)
@@ -1,41 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetImagData and mxSetImagData mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    void *data = mxGetImagData(prhs[0]);';
-       '    mxSetImagData(prhs[0], data);';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexGetSetImagData.c');
-ilib_mex_build('libmextest',['getSetImagData','mexGetSetImagData','cmex'], 'mexGetSetImagData.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    void *data = mxGetImagData(prhs[0]);";
+       "    mxSetImagData(prhs[0], data);";
+       "    plhs[0] = prhs[0];";
+       "}"],"mexGetSetImagData.c");
+ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[],"","","","");
+exec("loader.sce");
 r = getSetImagData(complex(1, 2));
-
-if r(1) <> complex(1, 2) then pause end
+assert_checkequal(r(1), complex(1, 2));
index e8ab407..eb56b75 100644 (file)
@@ -6,22 +6,21 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetImagData and mxSetImagData mex functions
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    void *data = mxGetImagData(prhs[0]);';
-       '    mxSetImagData(prhs[0], data);';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexGetSetImagData.c');
-ilib_mex_build('libmextest',['getSetImagData','mexGetSetImagData','cmex'], 'mexGetSetImagData.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    void *data = mxGetImagData(prhs[0]);";
+"    mxSetImagData(prhs[0], data);";
+"    plhs[0] = prhs[0];";
+"}"],"mexGetSetImagData.c");
+ilib_mex_build("libmextest",["getSetImagData","mexGetSetImagData","cmex"], "mexGetSetImagData.c",[],"","","","");
+exec("loader.sce");
 
 r = getSetImagData(complex(1, 2));
-if r(1) <> complex(1, 2) then pause end
+assert_checkequal(r(1), complex(1, 2));
index ad05109..bb28e23 100644 (file)
@@ -1,64 +1,40 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetM, mxGetN, mSGetM, mxSetN mex functions
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '#include ""localization.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   int iRows = 0;';
-        '   int iCols = 0;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   iRows = mxGetM(prhs[0]);';
-        '   iCols = mxGetN(prhs[0]);';
-        '   mxSetM(prhs[0], iRows * 2);';
-        '   mxSetN(prhs[0], iCols * 2);';
-        '   plhs[0] = prhs[0];';
-        '}'],'mexGetSetMN.c');
-
-ilib_mex_build('libmextest',['expand','mexGetSetMN','cmex'], 'mexGetSetMN.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "#include ""localization.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int i = 0;";
+        "   int iRows = 0;";
+        "   int iCols = 0;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   iRows = mxGetM(prhs[0]);";
+        "   iCols = mxGetN(prhs[0]);";
+        "   mxSetM(prhs[0], iRows * 2);";
+        "   mxSetN(prhs[0], iCols * 2);";
+        "   plhs[0] = prhs[0];";
+        "}"],"mexGetSetMN.c");
+ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[],"","","","");
+exec("loader.sce");
 a = [1,2;3,4];
-
 ref = a;
-
 ref(4,4) = 0;
-
 b = expand(a);
-
-if b <> ref then pause end
-
+assert_checkequal(b, ref);
index b842300..c2fbed8 100644 (file)
@@ -6,7 +6,6 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetM, mxGetN, mSGetM, mxSetN mex functions
 // ============================================================================
@@ -15,31 +14,31 @@ cd(TMPDIR);
 ilib_verbose(0);
 
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '#include ""localization.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   int iRows = 0;';
-        '   int iCols = 0;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   iRows = mxGetM(prhs[0]);';
-        '   iCols = mxGetN(prhs[0]);';
-        '   mxSetM(prhs[0], iRows * 2);';
-        '   mxSetN(prhs[0], iCols * 2);';
-        '   plhs[0] = prhs[0];';
-        '}'],'mexGetSetMN.c');
-ilib_mex_build('libmextest',['expand','mexGetSetMN','cmex'], 'mexGetSetMN.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"#include ""localization.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   int iRows = 0;";
+"   int iCols = 0;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   iRows = mxGetM(prhs[0]);";
+"   iCols = mxGetN(prhs[0]);";
+"   mxSetM(prhs[0], iRows * 2);";
+"   mxSetN(prhs[0], iCols * 2);";
+"   plhs[0] = prhs[0];";
+"}"],"mexGetSetMN.c");
+ilib_mex_build("libmextest",["expand","mexGetSetMN","cmex"], "mexGetSetMN.c",[],"","","","");
+exec("loader.sce");
 
 a = [1,2;3,4];
 ref = a;
 ref(4,4) = 0;
 b = expand(a);
-if b <> ref then pause end
+assert_checkequal(b, ref);
index 3c6a116..053f27b 100644 (file)
@@ -1,67 +1,43 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetPr, mxGetPi, mSGetPr, mxSetPi,  mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   int iSize = 0;';
-        '   mxArray* pOut = NULL;';
-        '   double* pDblR = NULL;';
-        '   double* pDblI = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   iSize = mxGetNumberOfElements(prhs[0]);';
-        '   pDblR = mxGetPr(prhs[0]);';
-        '   pDblI = mxGetPi(prhs[0]);';
-        '   pOut = mxCreateDoubleMatrix(1, iSize, 1);';
-        '   mxSetPr(pOut, pDblI);';
-        '   mxSetPi(pOut, pDblR);';
-        '   plhs[0] = pOut;';
-        '}'],'mexswapRI.c');
-
-ilib_mex_build('libmextest',['swapRI','mexswapRI','cmex'], 'mexswapRI.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int i = 0;";
+        "   int iSize = 0;";
+        "   mxArray* pOut = NULL;";
+        "   double* pDblR = NULL;";
+        "   double* pDblI = NULL;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   iSize = mxGetNumberOfElements(prhs[0]);";
+        "   pDblR = mxGetPr(prhs[0]);";
+        "   pDblI = mxGetPi(prhs[0]);";
+        "   pOut = mxCreateDoubleMatrix(1, iSize, 1);";
+        "   mxSetPr(pOut, pDblI);";
+        "   mxSetPi(pOut, pDblR);";
+        "   plhs[0] = pOut;";
+        "}"],"mexswapRI.c");
+ilib_mex_build("libmextest",["swapRI","mexswapRI","cmex"], "mexswapRI.c",[],"","","","");
+exec("loader.sce");
 a = 1:8;
-
 b = 8:-1:1;
-
 var1 = a + b * %i;
-
 ref = b + a * %i;
-
 var2 = swapRI(var1);
-
-if var2 <> ref then pause end
-
+assert_checkequal(var2, ref);
index 4d2ce71..ee22f4e 100644 (file)
@@ -6,44 +6,43 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetPr, mxGetPi, mSGetPr, mxSetPi,  mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int i = 0;';
-        '   int iSize = 0;';
-        '   mxArray* pOut = NULL;';
-        '   double* pDblR = NULL;';
-        '   double* pDblI = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   iSize = mxGetNumberOfElements(prhs[0]);';
-        '   pDblR = mxGetPr(prhs[0]);';
-        '   pDblI = mxGetPi(prhs[0]);';
-        '   pOut = mxCreateDoubleMatrix(1, iSize, 1);';
-        '   mxSetPr(pOut, pDblI);';
-        '   mxSetPi(pOut, pDblR);';
-        '   plhs[0] = pOut;';
-        '}'],'mexswapRI.c');
-ilib_mex_build('libmextest',['swapRI','mexswapRI','cmex'], 'mexswapRI.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int i = 0;";
+"   int iSize = 0;";
+"   mxArray* pOut = NULL;";
+"   double* pDblR = NULL;";
+"   double* pDblI = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   iSize = mxGetNumberOfElements(prhs[0]);";
+"   pDblR = mxGetPr(prhs[0]);";
+"   pDblI = mxGetPi(prhs[0]);";
+"   pOut = mxCreateDoubleMatrix(1, iSize, 1);";
+"   mxSetPr(pOut, pDblI);";
+"   mxSetPi(pOut, pDblR);";
+"   plhs[0] = pOut;";
+"}"],"mexswapRI.c");
+ilib_mex_build("libmextest",["swapRI","mexswapRI","cmex"], "mexswapRI.c",[],"","","","");
+exec("loader.sce");
 
 a = 1:8;
 b = 8:-1:1;
 var1 = a + b * %i;
 ref = b + a * %i;
 var2 = swapRI(var1);
-if var2 <> ref then pause end
+assert_checkequal(var2, ref);
 
 
index 072fb99..d53f08e 100644 (file)
@@ -1,56 +1,30 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxGetString mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char string[20];';
-       '    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, 20));';
-       '    plhs[1] = mxCreateString(string);';
-       '}'],'mexgetString.c');
-
-ilib_mex_build('libmextest',['getString','mexgetString','cmex'], 'mexgetString.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    char string[20];";
+       "    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, 20));";
+       "    plhs[1] = mxCreateString(string);";
+       "}"],"mexgetString.c");
+ilib_mex_build("libmextest",["getString","mexgetString","cmex"], "mexgetString.c",[],"","","","");
+exec("loader.sce");
 [out1, out2] = getString("String to copy.");
-
-if out1 <> 0 then pause end
-
-if out2 <> "String to copy." then pause end
-
+assert_checkequal(out1, 0);
+assert_checkequal(out2, "String to copy.");
 [out3, out4] = getString("A string bigger than 20 chars.");
-
-if out3 <> 1 then pause end
-
-if out4 <> "A string bigger tha" then pause end
-
+assert_checkequal(out3, 1);
+assert_checkequal(out4, "A string bigger tha");
 [out5, out6] = getString(["multiline"; "string"]);
-
-if out5 <> 0 then pause end
-
-if out6 <> "multilinestring" then pause end
+assert_checkequal(out5, 0);
+assert_checkequal(out6, "multilinestring");
index c799127..512a56d 100644 (file)
@@ -6,31 +6,30 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxGetString mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    char string[20];';
-       '    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, 20));';
-       '    plhs[1] = mxCreateString(string);';
-       '}'],'mexgetString.c');
-ilib_mex_build('libmextest',['getString','mexgetString','cmex'], 'mexgetString.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    char string[20];";
+"    plhs[0] = mxCreateDoubleScalar(mxGetString(prhs[0], string, 20));";
+"    plhs[1] = mxCreateString(string);";
+"}"],"mexgetString.c");
+ilib_mex_build("libmextest",["getString","mexgetString","cmex"], "mexgetString.c",[],"","","","");
+exec("loader.sce");
 
 [out1, out2] = getString("String to copy.");
-if out1 <> 0 then pause end
-if out2 <> "String to copy." then pause end
+assert_checkequal(out1, 0);
+assert_checkequal(out2, "String to copy.");
 
 [out3, out4] = getString("A string bigger than 20 chars.");
-if out3 <> 1 then pause end
-if out4 <> "A string bigger tha" then pause end
+assert_checkequal(out3, 1);
+assert_checkequal(out4, "A string bigger tha");
 
 [out5, out6] = getString(["multiline"; "string"]);
-if out5 <> 0 then pause end
-if out6 <> "multilinestring" then pause end
+assert_checkequal(out5, 0);
+assert_checkequal(out6, "multilinestring");
index 05cfc1e..01e0679 100644 (file)
@@ -1,87 +1,69 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsClass mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxIsClass(prhs[0], ""cell"")) {';
-       '        mexPrintf(""cell\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""char"")) {';
-       '        mexPrintf(""char\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""double"")) {';
-       '        mexPrintf(""double\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""function_handle"")) {';
-       '        mexPrintf(""function_handle\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int8"")) {';
-       '        mexPrintf(""int8\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int16"")) {';
-       '        mexPrintf(""int16\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int32"")) {';
-       '        mexPrintf(""int32\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int64"")) {';
-       '        mexPrintf(""int64\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""logical"")) {';
-       '        mexPrintf(""logical\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""single"")) {';
-       '        mexPrintf(""single\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""struct"")) {';
-       '        mexPrintf(""struct\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint8"")) {';
-       '        mexPrintf(""uint8\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint16"")) {';
-       '        mexPrintf(""uint16\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint32"")) {';
-       '        mexPrintf(""uint32\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint64"")) {';
-       '        mexPrintf(""uint64\n"");';
-       '    }'
-       '}'],'mexisClass.c');
-
-ilib_mex_build('libmextest',['printClass','mexisClass','cmex'], 'mexisClass.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxIsClass(prhs[0], ""cell"")) {";
+"        mexPrintf(""cell\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""char"")) {";
+"        mexPrintf(""char\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""double"")) {";
+"        mexPrintf(""double\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""function_handle"")) {";
+"        mexPrintf(""function_handle\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int8"")) {";
+"        mexPrintf(""int8\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int16"")) {";
+"        mexPrintf(""int16\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int32"")) {";
+"        mexPrintf(""int32\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int64"")) {";
+"        mexPrintf(""int64\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""logical"")) {";
+"        mexPrintf(""logical\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""single"")) {";
+"        mexPrintf(""single\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""struct"")) {";
+"        mexPrintf(""struct\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint8"")) {";
+"        mexPrintf(""uint8\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint16"")) {";
+"        mexPrintf(""uint16\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint32"")) {";
+"        mexPrintf(""uint32\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint64"")) {";
+"        mexPrintf(""uint64\n"");";
+"    }"
+"}"],"mexisClass.c");
+ilib_mex_build("libmextest",["printClass","mexisClass","cmex"], "mexisClass.c",[],"","","","");
+exec("loader.sce");
 printClass(cell());
 cell
-printClass('s');
+printClass("s");
 char
 printClass(1);
 double
index 4e0c057..2ebfd6f 100644 (file)
@@ -6,68 +6,67 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsClass mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    if (mxIsClass(prhs[0], ""cell"")) {';
-       '        mexPrintf(""cell\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""char"")) {';
-       '        mexPrintf(""char\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""double"")) {';
-       '        mexPrintf(""double\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""function_handle"")) {';
-       '        mexPrintf(""function_handle\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int8"")) {';
-       '        mexPrintf(""int8\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int16"")) {';
-       '        mexPrintf(""int16\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int32"")) {';
-       '        mexPrintf(""int32\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""int64"")) {';
-       '        mexPrintf(""int64\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""logical"")) {';
-       '        mexPrintf(""logical\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""single"")) {';
-       '        mexPrintf(""single\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""struct"")) {';
-       '        mexPrintf(""struct\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint8"")) {';
-       '        mexPrintf(""uint8\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint16"")) {';
-       '        mexPrintf(""uint16\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint32"")) {';
-       '        mexPrintf(""uint32\n"");';
-       '    }'
-       '    if (mxIsClass(prhs[0], ""uint64"")) {';
-       '        mexPrintf(""uint64\n"");';
-       '    }'
-       '}'],'mexisClass.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    if (mxIsClass(prhs[0], ""cell"")) {";
+"        mexPrintf(""cell\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""char"")) {";
+"        mexPrintf(""char\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""double"")) {";
+"        mexPrintf(""double\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""function_handle"")) {";
+"        mexPrintf(""function_handle\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int8"")) {";
+"        mexPrintf(""int8\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int16"")) {";
+"        mexPrintf(""int16\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int32"")) {";
+"        mexPrintf(""int32\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""int64"")) {";
+"        mexPrintf(""int64\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""logical"")) {";
+"        mexPrintf(""logical\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""single"")) {";
+"        mexPrintf(""single\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""struct"")) {";
+"        mexPrintf(""struct\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint8"")) {";
+"        mexPrintf(""uint8\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint16"")) {";
+"        mexPrintf(""uint16\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint32"")) {";
+"        mexPrintf(""uint32\n"");";
+"    }"
+"    if (mxIsClass(prhs[0], ""uint64"")) {";
+"        mexPrintf(""uint64\n"");";
+"    }"
+"}"],"mexisClass.c");
 
-ilib_mex_build('libmextest',['printClass','mexisClass','cmex'], 'mexisClass.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["printClass","mexisClass","cmex"], "mexisClass.c",[],"","","","");
+exec("loader.sce");
 
 printClass(cell());
-printClass('s');
+printClass("s");
 printClass(1);
 printClass(sum);
 printClass(int8(1));
index 25c01a4..5ad612a 100644 (file)
@@ -1,55 +1,29 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsComplex mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    bool isComplex = mxIsComplex(prhs[0]);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isComplex);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisComplex.c');
-
-ilib_mex_build('libmextest',['isComplex','mexisComplex','cmex'], 'mexisComplex.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    bool isComplex = mxIsComplex(prhs[0]);";
+       "    mxArray* pOut = mxCreateLogicalScalar(isComplex);";
+       "    plhs[0] = pOut;";
+       "}"],"mexisComplex.c");
+ilib_mex_build("libmextest",["isComplex","mexisComplex","cmex"], "mexisComplex.c",[],"","","","");
+exec("loader.sce");
 a = isComplex(1);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
 a = isComplex(1+0*%i);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
 a = isComplex(2+1*%i);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
 a = isComplex(complex(1, 1));
-
-if a <> %t then pause end
-
+assert_checktrue(a);
index aa21c99..ef52b52 100644 (file)
@@ -6,32 +6,31 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsComplex mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    bool isComplex = mxIsComplex(prhs[0]);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isComplex);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisComplex.c');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    bool isComplex = mxIsComplex(prhs[0]);";
+"    mxArray* pOut = mxCreateLogicalScalar(isComplex);";
+"    plhs[0] = pOut;";
+"}"],"mexisComplex.c");
 
-ilib_mex_build('libmextest',['isComplex','mexisComplex','cmex'], 'mexisComplex.c',[],'Makelib','','','');
-exec('loader.sce');
+ilib_mex_build("libmextest",["isComplex","mexisComplex","cmex"], "mexisComplex.c",[],"","","","");
+exec("loader.sce");
 
 a = isComplex(1);
-if a <> %f then pause end
+assert_checkfalse(a);
 
 a = isComplex(1+0*%i);
-if a <> %t then pause end
+assert_checktrue(a);
 
 a = isComplex(2+1*%i);
-if a <> %t then pause end
+assert_checktrue(a);
 
 a = isComplex(complex(1, 1));
-if a <> %t then pause end
+assert_checktrue(a);
index 56a76e4..867a5d0 100644 (file)
@@ -1,76 +1,44 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2009 - DIGITEO - Allan CORNET
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsEmpty mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int bEmpty = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   bEmpty = mxIsEmpty(prhs[0]);';
-        '   pOut = mxCreateLogicalScalar(bEmpty);';
-        '   plhs[0] = pOut;';
-        '}'],'mexIsEmpty.c');
-
-ilib_mex_build('libmextest',['isEmpty','mexIsEmpty','cmex'], 'mexIsEmpty.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "   int bEmpty = 0;";
+        "   mxArray* pOut = NULL;";
+        "";
+        "   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+        "   {";
+        "       mexErrMsgTxt(""Wrong number or type of input argument"");";
+        "   }";
+        "";
+        "   bEmpty = mxIsEmpty(prhs[0]);";
+        "   pOut = mxCreateLogicalScalar(bEmpty);";
+        "   plhs[0] = pOut;";
+        "}"],"mexIsEmpty.c");
+ilib_mex_build("libmextest",["isEmpty","mexIsEmpty","cmex"], "mexIsEmpty.c",[],"","","","");
+exec("loader.sce");
 a = list();
-
-if isEmpty(a) <> %t then pause end
-
+assert_checktrue(isEmpty(a));
 a = list(1);
-
-if isEmpty(a) <> %f then pause end
-
+assert_checkfalse(isEmpty(a));
 a = {};
-
-if isEmpty(a) <> %t then pause end
-
+assert_checktrue(isEmpty(a));
 a = {1};
-
-if isEmpty(a) <> %f then pause end
-
+assert_checkfalse(isEmpty(a));
 a = [];
-
-if isEmpty(a) <> %t then pause end
-
+assert_checktrue(isEmpty(a));
 a = [1];
-
-if isEmpty(a) <> %f then pause end
-
+assert_checkfalse(isEmpty(a));
 a = "";
-
-if isEmpty(a) <> %f then pause end
-
+assert_checkfalse(isEmpty(a));
index 9be9ca0..0b01ee8 100644 (file)
@@ -6,51 +6,50 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsEmpty mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        '';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '   int bEmpty = 0;';
-        '   mxArray* pOut = NULL;';
-        '';
-        '   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)';
-        '   {';
-        '       mexErrMsgTxt(""Wrong number or type of input argument"");';
-        '   }';
-        '';
-        '   bEmpty = mxIsEmpty(prhs[0]);';
-        '   pOut = mxCreateLogicalScalar(bEmpty);';
-        '   plhs[0] = pOut;';
-        '}'],'mexIsEmpty.c');
-ilib_mex_build('libmextest',['isEmpty','mexIsEmpty','cmex'], 'mexIsEmpty.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"   int bEmpty = 0;";
+"   mxArray* pOut = NULL;";
+"";
+"   if(nrhs != 1 /*|| !mxIsDouble(prhs[0])*/)";
+"   {";
+"       mexErrMsgTxt(""Wrong number or type of input argument"");";
+"   }";
+"";
+"   bEmpty = mxIsEmpty(prhs[0]);";
+"   pOut = mxCreateLogicalScalar(bEmpty);";
+"   plhs[0] = pOut;";
+"}"],"mexIsEmpty.c");
+ilib_mex_build("libmextest",["isEmpty","mexIsEmpty","cmex"], "mexIsEmpty.c",[],"","","","");
+exec("loader.sce");
 
 a = list();
-if isEmpty(a) <> %t then pause end
+assert_checktrue(isEmpty(a));
 
 a = list(1);
-if isEmpty(a) <> %f then pause end
+assert_checkfalse(isEmpty(a));
 
 a = {};
-if isEmpty(a) <> %t then pause end
+assert_checktrue(isEmpty(a));
 
 a = {1};
-if isEmpty(a) <> %f then pause end
+assert_checkfalse(isEmpty(a));
 
 a = [];
-if isEmpty(a) <> %t then pause end
+assert_checktrue(isEmpty(a));
 
 a = [1];
-if isEmpty(a) <> %f then pause end
+assert_checkfalse(isEmpty(a));
 
 a = "";
-if isEmpty(a) <> %f then pause end
+assert_checkfalse(isEmpty(a));
 
 
index e426cbf..86709c6 100644 (file)
@@ -1,60 +1,33 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsFinite mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isFinite = mxIsFinite(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isFinite);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisFinite.c');
-
-ilib_mex_build('libmextest',['isFinite','mexisFinite','cmex'], 'mexisFinite.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double value = mxGetScalar(prhs[0]);";
+       "    bool isFinite = mxIsFinite(value);";
+       "    mxArray* pOut = mxCreateLogicalScalar(isFinite);";
+       "    plhs[0] = pOut;";
+       "}"],"mexisFinite.c");
+ilib_mex_build("libmextest",["isFinite","mexisFinite","cmex"], "mexisFinite.c",[],"","","","");
+exec("loader.sce");
 a = isFinite(%inf);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
+ieee(2);
 a = isFinite(1/0);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
 a = isFinite(100);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
 a = isFinite(0);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
 a = isFinite(%nan);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
index e9da1d1..8a09b4d 100644 (file)
@@ -6,31 +6,31 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsFinite mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isFinite = mxIsFinite(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isFinite);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisFinite.c');
-ilib_mex_build('libmextest',['isFinite','mexisFinite','cmex'], 'mexisFinite.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double value = mxGetScalar(prhs[0]);";
+"    bool isFinite = mxIsFinite(value);";
+"    mxArray* pOut = mxCreateLogicalScalar(isFinite);";
+"    plhs[0] = pOut;";
+"}"],"mexisFinite.c");
+ilib_mex_build("libmextest",["isFinite","mexisFinite","cmex"], "mexisFinite.c",[],"","","","");
+exec("loader.sce");
 
 a = isFinite(%inf);
-if a <> %f then pause end
+assert_checkfalse(a);
+ieee(2);
 a = isFinite(1/0);
-if a <> %f then pause end
+assert_checkfalse(a);
 a = isFinite(100);
-if a <> %t then pause end
+assert_checktrue(a);
 a = isFinite(0);
-if a <> %t then pause end
+assert_checktrue(a);
 a = isFinite(%nan);
-if a <> %f then pause end
+assert_checkfalse(a);
index b9b05ca..aa71d3c 100644 (file)
@@ -1,56 +1,31 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsInf mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isInf = mxIsInf(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isInf);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisInf.c');
-
-ilib_mex_build('libmextest',['isInf','mexisInf','cmex'], 'mexisInf.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double value = mxGetScalar(prhs[0]);";
+       "    bool isInf = mxIsInf(value);";
+       "    mxArray* pOut = mxCreateLogicalScalar(isInf);";
+       "    plhs[0] = pOut;";
+       "}"],"mexisInf.c");
+ilib_mex_build("libmextest",["isInf","mexisInf","cmex"], "mexisInf.c",[],"","","","");
+exec("loader.sce");
 a = isInf(%inf);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
+ieee(2);
 a = isInf(1/0);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
 a = isInf(1);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
 a = isInf(%nan);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
index 095d421..94a7df2 100644 (file)
@@ -6,29 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsInf mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isInf = mxIsInf(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isInf);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisInf.c');
-ilib_mex_build('libmextest',['isInf','mexisInf','cmex'], 'mexisInf.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double value = mxGetScalar(prhs[0]);";
+"    bool isInf = mxIsInf(value);";
+"    mxArray* pOut = mxCreateLogicalScalar(isInf);";
+"    plhs[0] = pOut;";
+"}"],"mexisInf.c");
+ilib_mex_build("libmextest",["isInf","mexisInf","cmex"], "mexisInf.c",[],"","","","");
+exec("loader.sce");
 
 a = isInf(%inf);
-if a <> %t then pause end
+assert_checktrue(a);
+ieee(2);
 a = isInf(1/0);
-if a <> %t then pause end
+assert_checktrue(a);
 a = isInf(1);
-if a <> %f then pause end
+assert_checkfalse(a);
 a = isInf(%nan);
-if a <> %f then pause end
+assert_checkfalse(a);
index 861573e..c7a2f21 100644 (file)
@@ -1,50 +1,26 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsLogicalScalar mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    plhs[0] = mxCreateLogicalScalar(mxIsLogicalScalar(prhs[0]));';
-        '    plhs[1] = mxCreateLogicalScalar(mxIsLogicalScalarTrue(prhs[0]));';
-        '}'],'mexisLogicalScalar.c');
-
-ilib_mex_build('libmextest', ['isLogicalScalar', 'mexisLogicalScalar', 'cmex'], 'mexisLogicalScalar.c', [], 'Makelib', '', '', '');
-
-exec('loader.sce');
-
+mputl([ "#include ""mex.h""";
+        "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+        "{";
+        "    plhs[0] = mxCreateLogicalScalar(mxIsLogicalScalar(prhs[0]));";
+        "    plhs[1] = mxCreateLogicalScalar(mxIsLogicalScalarTrue(prhs[0]));";
+        "}"],"mexisLogicalScalar.c");
+ilib_mex_build("libmextest", ["isLogicalScalar", "mexisLogicalScalar", "cmex"], "mexisLogicalScalar.c", [], "", "", "", "");
+exec("loader.sce");
 [out1, out2] = isLogicalScalar(%t);
-
 [out3, out4] = isLogicalScalar(%f);
-
-if out1 <> %t then pause end
-
-if out2 <> %t then pause end
-
-if out3 <> %t then pause end
-
-if out4 <> %f then pause end
-
+assert_checktrue(out1);
+assert_checktrue(out2);
+assert_checktrue(out3);
+assert_checkfalse(out4);
index fcc7d7a..f83197f 100644 (file)
@@ -6,26 +6,25 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsLogicalScalar mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl([ '#include ""mex.h""';
-        'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-        '{';
-        '    plhs[0] = mxCreateLogicalScalar(mxIsLogicalScalar(prhs[0]));';
-        '    plhs[1] = mxCreateLogicalScalar(mxIsLogicalScalarTrue(prhs[0]));';
-        '}'],'mexisLogicalScalar.c');
-ilib_mex_build('libmextest', ['isLogicalScalar', 'mexisLogicalScalar', 'cmex'], 'mexisLogicalScalar.c', [], 'Makelib', '', '', '');
-exec('loader.sce');
+mputl([ "#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    plhs[0] = mxCreateLogicalScalar(mxIsLogicalScalar(prhs[0]));";
+"    plhs[1] = mxCreateLogicalScalar(mxIsLogicalScalarTrue(prhs[0]));";
+"}"],"mexisLogicalScalar.c");
+ilib_mex_build("libmextest", ["isLogicalScalar", "mexisLogicalScalar", "cmex"], "mexisLogicalScalar.c", [], "", "", "", "");
+exec("loader.sce");
 
 [out1, out2] = isLogicalScalar(%t);
 [out3, out4] = isLogicalScalar(%f);
 
-if out1 <> %t then pause end
-if out2 <> %t then pause end
-if out3 <> %t then pause end
-if out4 <> %f then pause end
+assert_checktrue(out1);
+assert_checktrue(out2);
+assert_checktrue(out3);
+assert_checkfalse(out4);
index 6e9ab6a..b772578 100644 (file)
@@ -1,56 +1,31 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxIsNaN mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isNaN = mxIsNaN(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isNaN);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisNaN.c');
-
-ilib_mex_build('libmextest',['isNaN','mexisNaN','cmex'], 'mexisNaN.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double value = mxGetScalar(prhs[0]);";
+       "    bool isNaN = mxIsNaN(value);";
+       "    mxArray* pOut = mxCreateLogicalScalar(isNaN);";
+       "    plhs[0] = pOut;";
+       "}"],"mexisNaN.c");
+ilib_mex_build("libmextest",["isNaN","mexisNaN","cmex"], "mexisNaN.c",[],"","","","");
+exec("loader.sce");
 a = isNaN(%inf);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
+ieee(2);
 a = isNaN(1/0);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
 a = isNaN(1);
-
-if a <> %f then pause end
-
+assert_checkfalse(a);
 a = isNaN(%nan);
-
-if a <> %t then pause end
-
+assert_checktrue(a);
index d19d646..7061bb1 100644 (file)
@@ -6,29 +6,29 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxIsNaN mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double value = mxGetScalar(prhs[0]);';
-       '    bool isNaN = mxIsNaN(value);';
-       '    mxArray* pOut = mxCreateLogicalScalar(isNaN);';
-       '    plhs[0] = pOut;';
-       '}'],'mexisNaN.c');
-ilib_mex_build('libmextest',['isNaN','mexisNaN','cmex'], 'mexisNaN.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double value = mxGetScalar(prhs[0]);";
+"    bool isNaN = mxIsNaN(value);";
+"    mxArray* pOut = mxCreateLogicalScalar(isNaN);";
+"    plhs[0] = pOut;";
+"}"],"mexisNaN.c");
+ilib_mex_build("libmextest",["isNaN","mexisNaN","cmex"], "mexisNaN.c",[],"","","","");
+exec("loader.sce");
 
 a = isNaN(%inf);
-if a <> %f then pause end
+assert_checkfalse(a);
+ieee(2);
 a = isNaN(1/0);
-if a <> %f then pause end
+assert_checkfalse(a);
 a = isNaN(1);
-if a <> %f then pause end
+assert_checkfalse(a);
 a = isNaN(%nan);
-if a <> %t then pause end
+assert_checktrue(a);
index 8abd0a6..5cd3999 100644 (file)
@@ -1,45 +1,26 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxMalloc mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double *data = mxMalloc(2 * sizeof(double *));';
-       '    data[0] = 1.0;';
-       '    data[1] = 3.2;';
-       '    plhs[0] = mxCreateDoubleMatrix(2, 1, mxREAL);'
-       '    mxSetPr(plhs[0], data);';
-       '}'],'mexmalloc.c');
-ilib_mex_build('libmextest',['malloc','mexmalloc','cmex'], 'mexmalloc.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    double *data = mxMalloc(2 * sizeof(double *));";
+       "    data[0] = 1.0;";
+       "    data[1] = 3.2;";
+       "    plhs[0] = mxCreateDoubleMatrix(2, 1, mxREAL);"
+       "    mxSetPr(plhs[0], data);";
+       "}"],"mexmalloc.c");
+ilib_mex_build("libmextest",["malloc","mexmalloc","cmex"], "mexmalloc.c",[],"","","","");
+exec("loader.sce");
 r = malloc();
-
-if r(1) <> 1 then pause end
-
-if r(2) <> 3.2 then pause end
+assert_checkequal(r(1), 1);
+assert_checkequal(r(2), 3.2);
index c42309e..50b68f9 100644 (file)
@@ -6,25 +6,24 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxMalloc mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    double *data = mxMalloc(2 * sizeof(double *));';
-       '    data[0] = 1.0;';
-       '    data[1] = 3.2;';
-       '    plhs[0] = mxCreateDoubleMatrix(2, 1, mxREAL);'
-       '    mxSetPr(plhs[0], data);';
-       '}'],'mexmalloc.c');
-ilib_mex_build('libmextest',['malloc','mexmalloc','cmex'], 'mexmalloc.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    double *data = mxMalloc(2 * sizeof(double *));";
+"    data[0] = 1.0;";
+"    data[1] = 3.2;";
+"    plhs[0] = mxCreateDoubleMatrix(2, 1, mxREAL);"
+"    mxSetPr(plhs[0], data);";
+"}"],"mexmalloc.c");
+ilib_mex_build("libmextest",["malloc","mexmalloc","cmex"], "mexmalloc.c",[],"","","","");
+exec("loader.sce");
 
 r = malloc();
-if r(1) <> 1 then pause end
-if r(2) <> 3.2 then pause end
+assert_checkequal(r(1), 1);
+assert_checkequal(r(2), 3.2);
index 81b6e07..7d54c36 100644 (file)
@@ -1,55 +1,27 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxSetCell mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *pOut = mxCreateCellMatrix(3, 3);';
-       '    mxSetCell(pOut, 0, mxCreateDoubleScalar(1));';
-       '    mxSetCell(pOut, 5, mxCreateDoubleScalar(9));';
-       '    mxSetCell(pOut, 7, mxGetCell(pOut, 5));';
-       '    plhs[0] = pOut;';
-       '}'],'mexsetCell.c');
-
-ilib_mex_build('libmextest',['setCell','mexsetCell','cmex'], 'mexsetCell.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxArray *pOut = mxCreateCellMatrix(3, 3);";
+       "    mxSetCell(pOut, 0, mxCreateDoubleScalar(1));";
+       "    mxSetCell(pOut, 5, mxCreateDoubleScalar(9));";
+       "    mxSetCell(pOut, 7, mxGetCell(pOut, 5));";
+       "    plhs[0] = pOut;";
+       "}"],"mexsetCell.c");
+ilib_mex_build("libmextest",["setCell","mexsetCell","cmex"], "mexsetCell.c",[],"","","","");
+exec("loader.sce");
 out = setCell();
-
-if size(out) <> [3,3] then pause end;
-
-ref = {1,[],[];[],[],9;[],9,[]}
-ref  = 
-
-  [1x1 constant]  [0x0 constant]  [0x0 constant]
-  [0x0 constant]  [0x0 constant]  [1x1 constant]
-  [0x0 constant]  [1x1 constant]  [0x0 constant]
-
-
-if out <> ref then pause end;
-
+assert_checkequal(size(out), [3,3]);
+ref = {1,[],[];[],[],9;[],9,[]};
+assert_checkequal(out, ref);
index 3223faf..1c4a33e 100644 (file)
@@ -6,27 +6,26 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxSetCell mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxArray *pOut = mxCreateCellMatrix(3, 3);';
-       '    mxSetCell(pOut, 0, mxCreateDoubleScalar(1));';
-       '    mxSetCell(pOut, 5, mxCreateDoubleScalar(9));';
-       '    mxSetCell(pOut, 7, mxGetCell(pOut, 5));';
-       '    plhs[0] = pOut;';
-       '}'],'mexsetCell.c');
-ilib_mex_build('libmextest',['setCell','mexsetCell','cmex'], 'mexsetCell.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxArray *pOut = mxCreateCellMatrix(3, 3);";
+"    mxSetCell(pOut, 0, mxCreateDoubleScalar(1));";
+"    mxSetCell(pOut, 5, mxCreateDoubleScalar(9));";
+"    mxSetCell(pOut, 7, mxGetCell(pOut, 5));";
+"    plhs[0] = pOut;";
+"}"],"mexsetCell.c");
+ilib_mex_build("libmextest",["setCell","mexsetCell","cmex"], "mexsetCell.c",[],"","","","");
+exec("loader.sce");
 
 out = setCell();
-if size(out) <> [3,3] then pause end;
+assert_checkequal(size(out), [3,3]);
 
-ref = {1,[],[];[],[],9;[],9,[]}
-if out <> ref then pause end;
+ref = {1,[],[];[],[],9;[],9,[]};
+assert_checkequal(out, ref);
index 32d2bfa..f2dada6 100644 (file)
@@ -1,46 +1,24 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxSetDimentsions mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {2,2};';
-       '    mxSetDimensions(prhs[0], dims, 2);';
-       '}'],'mexsetDimensions.c');
-
-ilib_mex_build('libmextest',['setDimensions','mexsetDimensions','cmex'], 'mexsetDimensions.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    int dims[2] = {2,2};";
+       "    mxSetDimensions(prhs[0], dims, 2);";
+       "}"],"mexsetDimensions.c");
+ilib_mex_build("libmextest",["setDimensions","mexsetDimensions","cmex"], "mexsetDimensions.c",[],"","","","");
+exec("loader.sce");
 a = [3];
-
 setDimensions(a);
-
-if size(a, "*") <> 4 then pause end
-
-if a(1) <> 3 then pause end
-
+assert_checkequal(size(a, "*"), 4);
+assert_checkequal(a(1), 3);
index 187c031..90a07df 100644 (file)
@@ -6,23 +6,22 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxSetDimentsions mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    int dims[2] = {2,2};';
-       '    mxSetDimensions(prhs[0], dims, 2);';
-       '}'],'mexsetDimensions.c');
-ilib_mex_build('libmextest',['setDimensions','mexsetDimensions','cmex'], 'mexsetDimensions.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    int dims[2] = {2,2};";
+"    mxSetDimensions(prhs[0], dims, 2);";
+"}"],"mexsetDimensions.c");
+ilib_mex_build("libmextest",["setDimensions","mexsetDimensions","cmex"], "mexsetDimensions.c",[],"","","","");
+exec("loader.sce");
 
 a = [3];
 setDimensions(a);
-if size(a, "*") <> 4 then pause end
-if a(1) <> 3 then pause end
+assert_checkequal(size(a, "*"), 4);
+assert_checkequal(a(1), 3);
index 214ab99..80f5cc9 100644 (file)
@@ -1,44 +1,23 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxSetField mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxSetField(prhs[0], 0, ""a"", mxCreateDoubleScalar(3));';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexsetField.c');
-
-ilib_mex_build('libmextest',['setField','mexsetField','cmex'], 'mexsetField.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxSetField(prhs[0], 0, ""a"", mxCreateDoubleScalar(3));";
+       "    plhs[0] = prhs[0];";
+       "}"],"mexsetField.c");
+ilib_mex_build("libmextest",["setField","mexsetField","cmex"], "mexsetField.c",[],"","","","");
+exec("loader.sce");
 s = struct("a", 1, "b", 2);
-
 r = setField(s);
-
-if r("a") <> 3 then pause end
-
+assert_checkequal(r("a"), 3);
index c455102..569e077 100644 (file)
@@ -6,23 +6,22 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxSetField mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxSetField(prhs[0], 0, ""a"", mxCreateDoubleScalar(3));';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexsetField.c');
-ilib_mex_build('libmextest',['setField','mexsetField','cmex'], 'mexsetField.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxSetField(prhs[0], 0, ""a"", mxCreateDoubleScalar(3));";
+"    plhs[0] = prhs[0];";
+"}"],"mexsetField.c");
+ilib_mex_build("libmextest",["setField","mexsetField","cmex"], "mexsetField.c",[],"","","","");
+exec("loader.sce");
 
 
 s = struct("a", 1, "b", 2);
 r = setField(s);
-if r("a") <> 3 then pause end
+assert_checkequal(r("a"), 3);
index 04a6dc4..79ea538 100644 (file)
@@ -1,47 +1,25 @@
-
 // ============================================================================
-
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-
 // Copyright (C) 2011-2011 - Gsoc 2011 - Iuri SILVIO
-
 //
-
 //  This file is distributed under the same license as the Scilab package.
-
 // ============================================================================
-
 // <-- JVM NOT MANDATORY -->
-
-// <-- ENGLISH IMPOSED -->
-
 // ============================================================================
-
 // Unitary tests for mxSetFieldByNumber mex function
-
 // ============================================================================
-
 cd(TMPDIR);
-
 ilib_verbose(0);
-
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxSetFieldByNumber(prhs[0], 0, 0, mxCreateDoubleScalar(3));';
-       '    mxSetFieldByNumber(prhs[0], 0, 1, mxCreateDoubleScalar(6));';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexsetFieldByNumber.c');
-
-ilib_mex_build('libmextest',['setFieldByNumber','mexsetFieldByNumber','cmex'], 'mexsetFieldByNumber.c',[],'Makelib','','','');
-
-exec('loader.sce');
-
+mputl(["#include ""mex.h""";
+       "void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+       "{";
+       "    mxSetFieldByNumber(prhs[0], 0, 0, mxCreateDoubleScalar(3));";
+       "    mxSetFieldByNumber(prhs[0], 0, 1, mxCreateDoubleScalar(6));";
+       "    plhs[0] = prhs[0];";
+       "}"],"mexsetFieldByNumber.c");
+ilib_mex_build("libmextest",["setFieldByNumber","mexsetFieldByNumber","cmex"], "mexsetFieldByNumber.c",[],"","","","");
+exec("loader.sce");
 s = struct("a", 1, "b", 2);
-
 r = setFieldByNumber(s);
-
-if r("a") <> 3 then pause end
-
-if r("b") <> 6 then pause end
-
+assert_checkequal(r("a"), 3);
+assert_checkequal(r("b"), 6);
index d42c83d..12e32ad 100644 (file)
@@ -6,24 +6,23 @@
 // ============================================================================
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 // ============================================================================
 // Unitary tests for mxSetFieldByNumber mex function
 // ============================================================================
 
 cd(TMPDIR);
 ilib_verbose(0);
-mputl(['#include ""mex.h""';
-       'void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])';
-       '{';
-       '    mxSetFieldByNumber(prhs[0], 0, 0, mxCreateDoubleScalar(3));';
-       '    mxSetFieldByNumber(prhs[0], 0, 1, mxCreateDoubleScalar(6));';
-       '    plhs[0] = prhs[0];';
-       '}'],'mexsetFieldByNumber.c');
-ilib_mex_build('libmextest',['setFieldByNumber','mexsetFieldByNumber','cmex'], 'mexsetFieldByNumber.c',[],'Makelib','','','');
-exec('loader.sce');
+mputl(["#include ""mex.h""";
+"void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])";
+"{";
+"    mxSetFieldByNumber(prhs[0], 0, 0, mxCreateDoubleScalar(3));";
+"    mxSetFieldByNumber(prhs[0], 0, 1, mxCreateDoubleScalar(6));";
+"    plhs[0] = prhs[0];";
+"}"],"mexsetFieldByNumber.c");
+ilib_mex_build("libmextest",["setFieldByNumber","mexsetFieldByNumber","cmex"], "mexsetFieldByNumber.c",[],"","","","");
+exec("loader.sce");
 
 s = struct("a", 1, "b", 2);
 r = setFieldByNumber(s);
-if r("a") <> 3 then pause end
-if r("b") <> 6 then pause end
+assert_checkequal(r("a"), 3);
+assert_checkequal(r("b"), 6);