* Bug #12144 fixed - csvRead triggers some errors about memory. 33/10733/4
Simon Marchetto [Thu, 7 Mar 2013 16:27:46 +0000 (17:27 +0100)]
if range column/row left indice is greater than column/row count, return error:
"Range row or/and column left indice(s) out of bounds"
(if right indice is out of bound, no error but truncate)

+ move csvRead bug_#353 test to dedicated range unit test
+ centralization: temp objects releasing (releaseObjects), range cheking (getRangeSize)

Change-Id: I7d4a0ca25bf9bdaaaf7b8e296e47e0486c9953ee

scilab/CHANGES_5.4.X
scilab/modules/spreadsheet/sci_gateway/c/sci_csvRead.c
scilab/modules/spreadsheet/src/c/getRange.c
scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.dia.ref [new file with mode: 0644]
scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.tst [new file with mode: 0644]
scilab/modules/spreadsheet/tests/nonreg_tests/ticket_353.dia.ref
scilab/modules/spreadsheet/tests/nonreg_tests/ticket_353.tst
scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.dia.ref [new file with mode: 0644]
scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.tst [new file with mode: 0644]

index 00c1cf7..99341cf 100644 (file)
@@ -275,7 +275,7 @@ Bug fixes
 
 * Bug #11134 fixed - xgetmouse() prevented callback menu execution.
 
-* Bug #11362 fixed - Doc of axes_properties did not explain that 
+* Bug #11362 fixed - Doc of axes_properties did not explain that
                      mark_style=mark_size=0 draw a single dot.
 
 * Bug #11436 fixed - With Matplot, color outside the colormap was replaced with
@@ -418,6 +418,9 @@ Bug fixes
 * Bug #12141 fixed - Remove calls to gettext in rubberbox help page examples.
                      Translation of items will be made in each language help page.
 
+* Bug #12144 fixed - csvRead triggered some error messages when ranges were
+                     wrong.
+
 * Bug #12151 fixed - Axes did not pass through (0,0) when x_location and
                      y_location were set to 'origin'.
 
@@ -474,7 +477,7 @@ Bug fixes
 
 * Bug #12285 fixed - export_to_hdf5 function could not handle any matrix in append mode.
 
-* Bug #12291 fixed - Unable to display a list of handle as an handle userData. 
+* Bug #12291 fixed - Unable to display a list of handle as an handle userData.
 
 * Bug #12296 fixed - Call to getenv with a big environment variable
                      led to memory corruption.
index d0e09e9..14fdb15 100644 (file)
@@ -31,6 +31,8 @@
 #include "gw_csv_helpers.h"
 #include "getRange.h"
 
+static void releaseObjects(csvResult *result, char *filename, char *conversion);
+
 /* ==================================================================== */
 #define CONVTOSTR "string"
 #define CONVTODOUBLE "double"
@@ -58,6 +60,8 @@ int sci_csvRead(char *fname, unsigned long fname_len)
 
     double *dRealValues = NULL;
 
+    sciErr.iErr = 0;
+
     CheckRhs(1, 7);
     CheckLhs(1, 2);
 
@@ -384,7 +388,16 @@ int sci_csvRead(char *fname, unsigned long fname_len)
                         }
                         else
                         {
-                            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            if ((newM == 0) || (newN == 0))
+                            {
+                                Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
+                            }
+                            else
+                            {
+                                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            }
+                            releaseObjects(result, filename, conversion);
+                            return 0;
                         }
                     }
                     else
@@ -399,17 +412,7 @@ int sci_csvRead(char *fname, unsigned long fname_len)
 
                     if (ptrCsvComplexArray == NULL)
                     {
-                        freeCsvResult(result);
-                        if (filename)
-                        {
-                            FREE(filename);
-                            filename = NULL;
-                        }
-                        if (conversion)
-                        {
-                            FREE(conversion);
-                            conversion = NULL;
-                        }
+                        releaseObjects(result, filename, conversion);
                         if (ierr == STRINGTOCOMPLEX_ERROR)
                         {
                             Scierror(999, _("%s: can not convert data.\n"), fname);
@@ -446,7 +449,16 @@ int sci_csvRead(char *fname, unsigned long fname_len)
                                 }
                                 else
                                 {
-                                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                                    if ((newM == 0) || (newN == 0))
+                                    {
+                                        Scierror(999, _("%s: Range row or/and column left indice(s) out of bounds.\n"), fname);
+                                    }
+                                    else
+                                    {
+                                        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                                    }
+                                    releaseObjects(result, filename, conversion);
+                                    return 0;
                                 }
                             }
                             else
@@ -468,30 +480,23 @@ int sci_csvRead(char *fname, unsigned long fname_len)
                         case STRINGTOCOMPLEX_MEMORY_ALLOCATION:
                         {
                             Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            releaseObjects(result, filename, conversion);
+                            return 0;
                         }
                         default:
                         case STRINGTOCOMPLEX_ERROR:
                         {
                             Scierror(999, _("%s: can not convert data.\n"), fname);
+                            releaseObjects(result, filename, conversion);
+                            return 0;
                         }
                     }
                 }
 
                 if (sciErr.iErr)
                 {
-                    freeCsvResult(result);
-                    if (filename)
-                    {
-                        FREE(filename);
-                        filename = NULL;
-                    }
-                    if (conversion)
-                    {
-                        FREE(conversion);
-                        conversion = NULL;
-                    }
-                    printError(&sciErr, 0);
-                    Scierror(17, _("%s: Memory allocation error.\n"), fname);
+                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                    releaseObjects(result, filename, conversion);
                     return 0;
                 }
                 else
@@ -503,19 +508,8 @@ int sci_csvRead(char *fname, unsigned long fname_len)
                         sciErr = createMatrixOfString(pvApiCtx, Rhs + 2, result->nbComments, 1, result->pstrComments);
                         if (sciErr.iErr)
                         {
-                            freeCsvResult(result);
-                            if (filename)
-                            {
-                                FREE(filename);
-                                filename = NULL;
-                            }
-                            if (conversion)
-                            {
-                                FREE(conversion);
-                                conversion = NULL;
-                            }
-                            printError(&sciErr, 0);
-                            Scierror(17, _("%s: Memory allocation error.\n"), fname);
+                            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            releaseObjects(result, filename, conversion);
                             return 0;
                         }
                         LhsVar(2) = Rhs + 2;
@@ -561,18 +555,18 @@ int sci_csvRead(char *fname, unsigned long fname_len)
     {
         Scierror(999, _("%s: Memory allocation error.\n"), fname);
     }
-    freeCsvResult(result);
-    if (filename)
-    {
-        FREE(filename);
-        filename = NULL;
-    }
-    if (conversion)
-    {
-        FREE(conversion);
-        conversion = NULL;
-    }
+    releaseObjects(result, filename, conversion);
 
     return 0;
 }
 /* ==================================================================== */
+static void releaseObjects(csvResult *result, char* filename, char* conversion)
+{
+    freeCsvResult(result);
+
+    FREE(filename);
+    filename = NULL;
+
+    FREE(conversion);
+    conversion = NULL;
+}
\ No newline at end of file
index 08ced60..c7c8639 100644 (file)
@@ -18,9 +18,7 @@
 // =============================================================================
 #define SIZE_ARRAY_RANGE 4
 // =============================================================================
-static int getSizeRange(const int *iRange, int nbRows, int nbCols);
-static int getSizeRows(const int *iRange, int nbRows);
-static int getSizeCols(const int *iRange, int nbCols);
+static int getRangeSize(int *lowCoord, int *highCoord, int maxCoord);
 // =============================================================================
 void getSubIndices(const int *iRange, int * R1, int * R2, int * C1, int * C2 )
 {
@@ -84,46 +82,36 @@ char **getRangeAsString(const char **pStrsValues,
 {
     if (isValidRange(iRange, SIZE_ARRAY_RANGE))
     {
-        char **newStrArray = NULL;
-        int sizeRange = getSizeRange(iRange, nbRows, nbCols);
         int R1, C1, R2, C2;
+        int rangeSize;
 
-        getSubIndices(iRange, &R1, &R2, &C1, &C2 );
+        getSubIndices(iRange, &R1, &R2, &C1, &C2);
 
-        *returnedNbRows = getSizeRows(iRange, nbRows);
-        *returnedNbCols = getSizeCols(iRange, nbCols);
+        *returnedNbRows = getRangeSize(&R1, &R2, nbRows);
+        *returnedNbCols = getRangeSize(&C1, &C2, nbCols);
 
-        newStrArray = (char**)MALLOC(sizeof(char*) * sizeRange);
-        if (newStrArray == NULL)
-        {
-            *returnedNbCols = 0;
-            *returnedNbRows = 0;
-        }
-        else
+        rangeSize = (*returnedNbRows) * (*returnedNbCols);
+        if (rangeSize > 0)
         {
-            int i = 0;
-            int j = 0;
-            int k = 0;
-
-            if ( C2 > nbCols )
-            {
-                C2 = nbCols;
-            }
-            if ( R2 > nbRows )
+            char **newStrArray = (char**)MALLOC(sizeof(char*) * rangeSize);
+            if (newStrArray != NULL)
             {
-                R2 = nbRows;
-            }
+                int i = 0;
+                int j = 0;
+                int k = 0;
 
-            for ( j = C1 - 1 ; j < C2 ; j++)
-            {
-                for (i = R1 - 1 ; i < R2 ; i++ )
+                for (j = C1 - 1 ; j < C2 ; j++)
                 {
-                    newStrArray[k] = strdup(pStrsValues[i + nbRows * j]);
-                    k++;
+                    for (i = R1 - 1 ; i < R2 ; i++ )
+                    {
+                        newStrArray[k] = strdup(pStrsValues[i + nbRows * j]);
+                        k++;
+                    }
                 }
             }
+            return newStrArray;
         }
-        return newStrArray;
+        // range is empty, calling function should raise an out of bound error
     }
     return NULL;
 }
@@ -135,107 +123,59 @@ csv_complexArray *getRangeAsCsvComplexArray(const csv_complexArray *pComplex,
 {
     if (isValidRange(iRange, SIZE_ARRAY_RANGE))
     {
-        csv_complexArray *newComplexArray = NULL;
-        int sizeRange = getSizeRange(iRange, nbRows, nbCols);
-        int R1 = 0, C1 = 0, R2 = 0, C2 = 0;
+        int R1, C1, R2, C2;
+        int rangeSize;
 
         getSubIndices(iRange, &R1, &R2, &C1, &C2 );
 
-        *returnedNbRows = getSizeRows(iRange, nbRows);
-        *returnedNbCols = getSizeCols(iRange, nbCols);
+        *returnedNbRows = getRangeSize(&R1, &R2, nbRows);
+        *returnedNbCols = getRangeSize(&C1, &C2, nbCols);
 
-        newComplexArray = createCsvComplexArrayEmpty(sizeRange);
-        if (newComplexArray == NULL)
-        {
-            *returnedNbCols = 0;
-            *returnedNbRows = 0;
-        }
-        else
+        rangeSize = (*returnedNbRows) * (*returnedNbCols);
+        if (rangeSize > 0)
         {
-            int i = 0;
-            int j = 0;
-            int k = 0;
-
-            if ( C2 > nbCols )
-            {
-                C2 = nbCols;
-            }
-            if ( R2 > nbRows )
+            csv_complexArray *newComplexArray =
+                createCsvComplexArrayEmpty(rangeSize);
+            if (newComplexArray != NULL)
             {
-                R2 = nbRows;
-            }
+                int i = 0;
+                int j = 0;
+                int k = 0;
 
-            newComplexArray->isComplex = pComplex->isComplex;
+                newComplexArray->isComplex = pComplex->isComplex;
 
-            for ( j = C1 - 1 ; j < C2 ; j++)
-            {
-                for (i = R1 - 1 ; i < R2 ; i++)
+                for (j = C1 - 1 ; j < C2 ; j++)
                 {
-                    newComplexArray->realPart[k] = pComplex->realPart[i + (nbRows * j)];
-                    if (pComplex->isComplex)
+                    for (i = R1 - 1 ; i < R2 ; i++)
                     {
-                        newComplexArray->imagPart[k] = pComplex->imagPart[i + (nbRows * j)];
+                        newComplexArray->realPart[k] = pComplex->realPart[i + (nbRows * j)];
+                        if (pComplex->isComplex)
+                        {
+                            newComplexArray->imagPart[k] = pComplex->imagPart[i + (nbRows * j)];
+                        }
+                        k++;
                     }
-                    k++;
                 }
             }
+            return newComplexArray;
         }
-
-        return newComplexArray;
+        // range is empty, calling function should raise an out of bound error
     }
     return NULL;
 }
 // =============================================================================
-static int getSizeRange(const int *iRange, int nbRows, int nbCols)
-{
-    int sizeRange;
-    if (iRange)
-    {
-        sizeRange = getSizeRows(iRange, nbRows) * getSizeCols(iRange, nbCols);
-    }
-    else
-    {
-        sizeRange = 0;
-    }
-    return sizeRange;
-}
-// =============================================================================
-static int getSizeRows(const int *iRange, int nbRows)
-{
-    int sizeRows = 0;
-    int R1, R2, C1, C2;
-
-    getSubIndices(iRange, &R1, &R2, &C1, &C2 );
-
-    if (iRange == NULL)
-    {
-        return 0;
-    }
-    if ( R2 > nbRows )
-    {
-        R2 = nbRows;
-    }
-    sizeRows = R2 - R1 + 1;
-    return sizeRows;
-}
-// =============================================================================
-static int getSizeCols(const int *iRange, int nbCols)
+static int getRangeSize(int *lowCoord, int *highCoord, int maxCoord)
 {
-    int sizeCols = 0;
-    int R1, R2, C1, C2;
-
-    getSubIndices(iRange, &R1, &R2, &C1, &C2 );
-
-    if (iRange == NULL)
+    // IsValidRange has done all checks of range, except on right bound
+    if (*lowCoord <= maxCoord)
     {
-        return 0;
-    }
-    if ( C2 > nbCols )
-    {
-        C2 = nbCols;
+        if (*highCoord > maxCoord)
+        {
+            *highCoord = maxCoord;
+        }
+        return *highCoord - *lowCoord + 1;
     }
-    sizeCols = C2 - C1 + 1;
-
-    return sizeCols;
+    // lower coord is out of bound
+    return 0;
 }
 // =============================================================================
diff --git a/scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.dia.ref b/scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.dia.ref
new file mode 100644 (file)
index 0000000..c1dd7f7
--- /dev/null
@@ -0,0 +1,30 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Simon MARCHETTO
+//
+// This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 12144 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=12144
+//
+// <-- Short Description -->
+// csvRead triggers some errors about memory
+CSV = ["1,0,0,0,0"; ..
+"0,1,0,0,0"; ..
+"0,0,1,0,0"; ..
+"4,4,1,2,0"; ..
+"4,63,1,2,0"; ..
+"4,63,1,2,233"; ..
+"42,3,23,2,233"; ..
+];
+filename = fullfile(TMPDIR, 'foo.csv');
+mputl(CSV, filename);
+instr = "r = csvRead(filename, "" "", [], ""string"", [], [], [5 3 7 6]);";
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+assert_checkerror(instr, refMsg);
+mdelete(filename);
diff --git a/scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.tst b/scilab/modules/spreadsheet/tests/nonreg_tests/bug_12144.tst
new file mode 100644 (file)
index 0000000..6ff3b98
--- /dev/null
@@ -0,0 +1,32 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Simon MARCHETTO
+//
+// This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+//
+// <-- Non-regression test for bug 12144 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=12144
+//
+// <-- Short Description -->
+// csvRead triggers some errors about memory
+
+
+CSV = ["1,0,0,0,0"; ..
+"0,1,0,0,0"; ..
+"0,0,1,0,0"; ..
+"4,4,1,2,0"; ..
+"4,63,1,2,0"; ..
+"4,63,1,2,233"; ..
+"42,3,23,2,233"; ..
+];
+filename = fullfile(TMPDIR, 'foo.csv');
+mputl(CSV, filename);
+instr = "r = csvRead(filename, "" "", [], ""string"", [], [], [5 3 7 6]);";
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+assert_checkerror(instr, refMsg);
+mdelete(filename);
index 3af7c0c..a7e4e57 100644 (file)
 // The csvRead function does not manage the range.
 // =================================g============================================
 path = SCI+"/modules/spreadsheet/tests/unit_tests/";
-//
 // Read only rows/columns in range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 3 2] );
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 3 2]);
 expected = [
 0.10000000000000001 1.1000000000000001
 0.10000000000000001 0.10000000000000001
 ];
-assert_checkequal ( r , expected );
-//
-//  Not symetric range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 2 2] );
-expected = [
-0.10000000000000001 1.1000000000000001
-];
-assert_checkequal ( r , expected );
-//
-// Read complex doubles
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 3 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Not symetric range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 2 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Inconsistent range: C2 < C1
-instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 3 3 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Inconsistent range: R2 < R1
-instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [3 1 2 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Non-integer indice
-instr="r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 1 1.5 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Infinite indice
-instr="r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 1 %inf 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Row indice larger than actual number of rows: string case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 999 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Column indice larger than actual number of columns: string case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 3 999] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Row indice larger than actual number of rows: double case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [3 1 999 2] );
-expected = [
-0.10000000000000001 0.10000000000000001
-];
-assert_checkequal ( r , expected );
-//
-// Column indice larger than actual number of columns: double case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 2 3 999] );
-expected = [
-1.1000000000000001
-0.10000000000000001
-];
-assert_checkequal ( r , expected );
-// r = csvRead(fullfile(path,"complexdata.csv"), [], [], "double" , [] , [], [2 1 3 2] );
-// Fails due to ticket #360
-// TODO : range of doubles complex 
-// TODO : Row indice larger than actual number of rows: complex double case
-// TODO : Col indice larger than actual number of columns: complex double case
-// =============================================================================
+assert_checkequal(r, expected);
index 1d0a08f..e6e44d9 100644 (file)
 // <-- Short Description -->
 // The csvRead function does not manage the range.
 // =================================g============================================
+
 path = SCI+"/modules/spreadsheet/tests/unit_tests/";
 
-//
 // Read only rows/columns in range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 3 2] );
-expected = [
-0.10000000000000001 1.1000000000000001
-0.10000000000000001 0.10000000000000001
-];
-assert_checkequal ( r , expected );
-//
-//  Not symetric range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 2 2] );
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 1 3 2]);
 expected = [
 0.10000000000000001 1.1000000000000001
-];
-assert_checkequal ( r , expected );
-//
-// Read complex doubles
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 3 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Not symetric range
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 2 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Inconsistent range: C2 < C1
-instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 3 3 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Inconsistent range: R2 < R1
-instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [3 1 2 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Non-integer indice
-instr="r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 1 1.5 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Infinite indice
-instr="r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"" , [] , [], [2 1 %inf 2] );";
-refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
-assert_checkerror ( instr , refMsg );
-//
-// Row indice larger than actual number of rows: string case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 999 2] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Column indice larger than actual number of columns: string case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "string" , [] , [], [2 1 3 999] );
-expected = [
-"0.10000000000000001" "1.1000000000000001"
-"0.10000000000000001" "0.10000000000000001"
-];
-assert_checkequal ( r , expected );
-//
-// Row indice larger than actual number of rows: double case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [3 1 999 2] );
-expected = [
 0.10000000000000001 0.10000000000000001
 ];
-assert_checkequal ( r , expected );
-//
-// Column indice larger than actual number of columns: double case
-r = csvRead(fullfile(path,"K_1.csv"), [], [], "double" , [] , [], [2 2 3 999] );
-expected = [
-1.1000000000000001
-0.10000000000000001
-];
-assert_checkequal ( r , expected );
-
-// r = csvRead(fullfile(path,"complexdata.csv"), [], [], "double" , [] , [], [2 1 3 2] );
-// Fails due to ticket #360
-// TODO : range of doubles complex 
-// TODO : Row indice larger than actual number of rows: complex double case
-// TODO : Col indice larger than actual number of columns: complex double case
-// =============================================================================
-
+assert_checkequal(r, expected);
diff --git a/scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.dia.ref b/scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.dia.ref
new file mode 100644 (file)
index 0000000..0dcbb27
--- /dev/null
@@ -0,0 +1,87 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Simon MARCHETTO
+//
+// This file is distributed under the same license as the Scilab package.
+// =============================================================================
+path = SCI + "/modules/spreadsheet/tests/unit_tests/";
+//  Not symetric range
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [2 1 2 2] );
+expected = [
+0.10000000000000001 1.1000000000000001
+];
+assert_checkequal(r, expected);
+// Read complex doubles
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 3 2] );
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+// Not symetric range
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 2 2]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+];
+assert_checkequal(r, expected);
+// Inconsistent range: C2 < C1
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 3 3 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+// Inconsistent range: R2 < R1
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [3 1 2 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+// Non-integer indice
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 1 1.5 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+// Infinite indice
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 1 %inf 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+// Row right indice greater than actual number of rows (string) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 999 2]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+// Column right indice greater than actual number of columns (string) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 3 999]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+// Row or column left indice greater than actual number of rows (string) => error
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""string"", [], [], [999 1 1000 2]);";
+assert_checkerror(instr, refMsg);
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""string"", [], [], [1 999 2 1000]);";
+assert_checkerror(instr, refMsg);
+// Row right indice greater than actual number of rows (double) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [3 1 999 2]);
+expected = [
+0.10000000000000001 0.10000000000000001
+];
+assert_checkequal(r, expected);
+// Column right indice greater than actual number of columns (double) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [2 2 3 999]);
+expected = [
+1.1000000000000001
+0.10000000000000001
+];
+assert_checkequal(r, expected);
+// Row or column left indice greater than actual number of rows (double) => error
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""double"", [], [], [999 1 1000 2]);";
+assert_checkerror(instr, refMsg);
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""double"", [], [], [1 999 2 1000]);";
+assert_checkerror(instr, refMsg);
+// r = csvRead(fullfile(path,"complexdata.csv"), [], [], "double", [], [], [2 1 3 2]);
+// Fails due to ticket #360
+// TODO : range of doubles complex
+// TODO : Row indice larger than actual number of rows: complex double case
+// TODO : Col indice larger than actual number of columns: complex double case
+// =============================================================================
diff --git a/scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.tst b/scilab/modules/spreadsheet/tests/unit_tests/csvRead_range.tst
new file mode 100644 (file)
index 0000000..3911275
--- /dev/null
@@ -0,0 +1,103 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Simon MARCHETTO
+//
+// This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+path = SCI + "/modules/spreadsheet/tests/unit_tests/";
+
+//  Not symetric range
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [2 1 2 2] );
+expected = [
+0.10000000000000001 1.1000000000000001
+];
+assert_checkequal(r, expected);
+
+// Read complex doubles
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 3 2] );
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+
+// Not symetric range
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 2 2]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+];
+assert_checkequal(r, expected);
+
+// Inconsistent range: C2 < C1
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 3 3 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+
+// Inconsistent range: R2 < R1
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [3 1 2 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: Inconsistent range.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+
+// Non-integer indice
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 1 1.5 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+
+// Infinite indice
+instr = "r = csvRead(fullfile(path,""K_1.csv""), [], [], ""string"", [], [], [2 1 %inf 2]);";
+refMsg = msprintf(gettext("%s: Wrong value for input argument #%d: A matrix of double, with integer values, expected.\n"), "csvRead", 7);
+assert_checkerror(instr, refMsg);
+
+// Row right indice greater than actual number of rows (string) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 999 2]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+
+// Column right indice greater than actual number of columns (string) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "string", [], [], [2 1 3 999]);
+expected = [
+"0.10000000000000001" "1.1000000000000001"
+"0.10000000000000001" "0.10000000000000001"
+];
+assert_checkequal(r, expected);
+
+// Row or column left indice greater than actual number of rows (string) => error
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""string"", [], [], [999 1 1000 2]);";
+assert_checkerror(instr, refMsg);
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""string"", [], [], [1 999 2 1000]);";
+assert_checkerror(instr, refMsg);
+
+// Row right indice greater than actual number of rows (double) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [3 1 999 2]);
+expected = [
+0.10000000000000001 0.10000000000000001
+];
+assert_checkequal(r, expected);
+
+// Column right indice greater than actual number of columns (double) => truncate
+r = csvRead(fullfile(path,"K_1.csv"), [], [], "double", [], [], [2 2 3 999]);
+expected = [
+1.1000000000000001
+0.10000000000000001
+];
+assert_checkequal(r, expected);
+
+// Row or column left indice greater than actual number of rows (double) => error
+refMsg = msprintf(gettext("%s: Range row or/and column left indice(s) out of bounds.\n"), "csvRead");
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""double"", [], [], [999 1 1000 2]);";
+assert_checkerror(instr, refMsg);
+instr = "r = csvRead(fullfile(path, ""K_1.csv""), [], [], ""double"", [], [], [1 999 2 1000]);";
+assert_checkerror(instr, refMsg);
+
+// r = csvRead(fullfile(path,"complexdata.csv"), [], [], "double", [], [], [2 1 3 2]);
+// Fails due to ticket #360
+// TODO : range of doubles complex
+// TODO : Row indice larger than actual number of rows: complex double case
+// TODO : Col indice larger than actual number of columns: complex double case
+// =============================================================================
+