* Javasci supports sparse datatypes retrieval (Javasci is able to retrieve
[scilab.git] / scilab / modules / types / tests / java / org / scilab / tests / modules / types / testEquals.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Sylvestre LEDRU
4  * Copyright (C) 2011 - Scilab Enterprises - Sylvestre LEDRU
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13 package org.scilab.tests.modules.types;
14
15 import org.testng.annotations.*;
16
17 import java.util.Arrays;
18
19 import org.scilab.modules.types.ScilabType;
20 import org.scilab.modules.types.ScilabDouble;
21 import org.scilab.modules.types.ScilabSparse;
22 import org.scilab.modules.types.ScilabInteger;
23 import org.scilab.modules.types.ScilabIntegerTypeEnum;
24 import org.scilab.modules.types.ScilabBoolean;
25 import org.scilab.modules.types.ScilabString;
26 import org.scilab.modules.types.ScilabList;
27 import org.scilab.modules.types.ScilabTList;
28 import org.scilab.modules.types.ScilabMList;
29 import org.scilab.modules.types.ScilabTypeEnum;
30
31 public class testEquals {
32
33         @Test
34         public void compareDoubleTest() throws NullPointerException {
35                 double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
36                 double [][]b={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
37                 double [][]c={{42,43},{21,22}};
38                 ScilabDouble aMatrix = new ScilabDouble(a);
39                 ScilabDouble bMatrix = new ScilabDouble(b);
40                 ScilabDouble cMatrix = new ScilabDouble(c);
41                 assert aMatrix.equals(bMatrix) == true;
42                 assert bMatrix.equals(aMatrix) == true;
43                 assert cMatrix.equals(aMatrix) == false;
44                 assert Arrays.deepEquals(aMatrix.getRealPart(), bMatrix.getRealPart()) == true;
45                 assert aMatrix.toString().equals("[21.2, 22.0, 42.0, 39.0 ; 23.2, 24.0, 44.0, 40.0]") == true;
46                 assert cMatrix.toString().equals("[42.0, 43.0 ; 21.0, 22.0]") == true;
47                 assert aMatrix.getType() == ScilabTypeEnum.sci_matrix;
48                 assert bMatrix.getType() == ScilabTypeEnum.sci_matrix;
49                 assert cMatrix.getType() == ScilabTypeEnum.sci_matrix;
50         }
51         @Test
52         public void compareSparseTest() throws NullPointerException {
53                 double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
54                 double [][]b={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
55                 double [][]c={{42,43},{21,22}};
56                 ScilabSparse aMatrix = new ScilabSparse(a);
57                 ScilabSparse bMatrix = new ScilabSparse(b);
58                 ScilabSparse cMatrix = new ScilabSparse(c);
59                 ScilabSparse matrixComplex = new ScilabSparse(a,b);
60                 assert aMatrix.equals(bMatrix) == true;
61                 assert bMatrix.equals(aMatrix) == true;
62                 assert cMatrix.equals(aMatrix) == false;
63                 assert Arrays.deepEquals(aMatrix.getFullRealPart(), bMatrix.getFullRealPart()) == true;
64                 assert aMatrix.toString().equals("sparse([1, 1 ; 1, 2 ; 1, 3 ; 1, 4 ; 2, 1 ; 2, 2 ; 2, 3 ; 2, 4], [21.2 ; 22.0 ; 42.0 ; 39.0 ; 23.2 ; 24.0 ; 44.0 ; 40.0], [2, 4])") == true;
65                 assert cMatrix.toString().equals("sparse([1, 1 ; 1, 2 ; 2, 1 ; 2, 2], [42.0 ; 43.0 ; 21.0 ; 22.0], [2, 2])") == true;
66                 assert matrixComplex.toString().equals("sparse([1, 1 ; 1, 2 ; 1, 3 ; 1, 4 ; 2, 1 ; 2, 2 ; 2, 3 ; 2, 4], [21.2+21.2*%i ; 22.0+22.0*%i ; 42.0+42.0*%i ; 39.0+39.0*%i ; 23.2+23.2*%i ; 24.0+24.0*%i ; 44.0+44.0*%i ; 40.0+40.0*%i], [2, 4])");
67                 assert aMatrix.getType() == ScilabTypeEnum.sci_sparse;
68                 assert bMatrix.getType() == ScilabTypeEnum.sci_sparse;
69                 assert cMatrix.getType() == ScilabTypeEnum.sci_sparse;
70         }
71
72         @Test
73         public void doubleMatrixTests() {
74                 double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
75                 ScilabDouble emptyMatrix = new ScilabDouble();
76                 assert emptyMatrix.getHeight() == 0;
77                 assert emptyMatrix.getWidth() == 0;
78                 assert emptyMatrix.isEmpty() == true;
79                 assert emptyMatrix.toString().equals("[]") == true;
80                 emptyMatrix.setRealPart(a);
81                 emptyMatrix.setImaginaryPart(a);
82                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_matrix;
83
84                 ScilabBoolean aMatrix = new ScilabBoolean(true);
85                 assert aMatrix.equals(emptyMatrix) == false;
86                 assert emptyMatrix.equals(aMatrix) == false;
87                 assert aMatrix.getType() != ScilabTypeEnum.sci_matrix;
88         }
89
90
91         @Test
92         public void compareDoubleComplexTest() throws NullPointerException {
93                 double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
94                 double [][]aImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};
95                 double [][]b={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
96                 double [][]bImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};
97                 double [][]c={{42,43},{21,22}};
98                 double [][]cImg={{420,430},{210,220}};
99                 ScilabDouble aMatrix = new ScilabDouble(a, aImg);
100                 ScilabDouble bMatrix = new ScilabDouble(b, bImg);
101                 ScilabDouble cMatrix = new ScilabDouble(c, cImg);
102                 assert aMatrix.equals(bMatrix) == true;
103                 assert bMatrix.equals(aMatrix) == true;
104                 assert cMatrix.equals(aMatrix) == false;
105                 assert aMatrix.getType() == ScilabTypeEnum.sci_matrix;
106                 assert bMatrix.getType() == ScilabTypeEnum.sci_matrix;
107                 assert cMatrix.getType() == ScilabTypeEnum.sci_matrix;
108
109                 assert Arrays.deepEquals(aMatrix.getRealPart(), bMatrix.getRealPart()) == true;
110                 assert Arrays.deepEquals(aMatrix.getImaginaryPart(), bMatrix.getImaginaryPart()) == true;
111                 assert aMatrix.toString().equals("[21.2 + 210.2 * %i, 22.0 + 220.0 * %i, 42.0 + 420.0 * %i, 39.0 + 390.0 * %i ; 23.2 + 230.2 * %i, 24.0 + 240.0 * %i, 44.0 + 440.0 * %i, 40.0 + 400.0 * %i]") == true;
112                 assert cMatrix.toString().equals("[42.0 + 420.0 * %i, 43.0 + 430.0 * %i ; 21.0 + 210.0 * %i, 22.0 + 220.0 * %i]") == true;
113
114                 double [] result = new double[]{21.2, 23.2, 22.0, 24.0, 42.0, 44.0, 39.0, 40.0, 210.2, 230.2, 220.0, 240.0, 420.0, 440.0, 390.0, 400.0};
115                 assert aMatrix.getSerializedComplexMatrix().length == result.length;
116                 assert Arrays.equals(aMatrix.getSerializedComplexMatrix(),result) == true;
117                 ScilabDouble scalarComplex = new ScilabDouble(1,2);
118                 assert aMatrix.equals(scalarComplex) == false;
119                 assert aMatrix.equals(bMatrix) == true;
120         }
121
122
123
124         @Test
125         public void sparseTest() throws NullPointerException {
126                 double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
127                 double [][]aImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};
128                 double [][]b={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
129                 double [][]bImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};
130                 double [][]c={{42,43},{21,22}};
131                 double [][]cImg={{420,430},{210,220}};
132                 ScilabSparse aMatrix = new ScilabSparse(a, aImg);
133                 ScilabSparse bMatrix = new ScilabSparse(b, bImg);
134                 ScilabSparse cMatrix = new ScilabSparse(c, cImg);
135                 assert aMatrix.equals(bMatrix) == true;
136                 assert bMatrix.equals(aMatrix) == true;
137                 assert cMatrix.equals(aMatrix) == false;
138                 assert aMatrix.getType() == ScilabTypeEnum.sci_sparse;
139                 assert bMatrix.getType() == ScilabTypeEnum.sci_sparse;
140                 assert cMatrix.getType() == ScilabTypeEnum.sci_sparse;
141
142                 assert Arrays.deepEquals(aMatrix.getFullRealPart(), bMatrix.getFullRealPart()) == true;
143                 assert Arrays.deepEquals(aMatrix.getFullImaginaryPart(), bMatrix.getFullImaginaryPart()) == true;
144                 assert aMatrix.toString().equals("sparse([1, 1 ; 1, 2 ; 1, 3 ; 1, 4 ; 2, 1 ; 2, 2 ; 2, 3 ; 2, 4], [21.2+210.2*%i ; 22.0+220.0*%i ; 42.0+420.0*%i ; 39.0+390.0*%i ; 23.2+230.2*%i ; 24.0+240.0*%i ; 44.0+440.0*%i ; 40.0+400.0*%i], [2, 4])");
145                 assert cMatrix.toString().equals("sparse([1, 1 ; 1, 2 ; 2, 1 ; 2, 2], [42.0+420.0*%i ; 43.0+430.0*%i ; 21.0+210.0*%i ; 22.0+220.0*%i], [2, 2])");
146
147                 ScilabSparse mySparse = new ScilabSparse(100, 100, 5, new int[] { 1, 1, 1, 1, 1}, new int[]{ 1, 25, 50, 75, 99}, new double[] { 1.0, 2.0, 3.0, 4.0, 5.0});
148 //fails for now
149 //              System.out.println(mySparse);
150         }
151
152
153         @Test
154         public void compareInteger8Test() throws NullPointerException {
155                 byte [][]a={{32,42,41}, {12,13,32}};
156                 byte [][]b={{32,42,41}, {12,13,32}};
157                 byte [][]c={{42,43},{21,22}};
158                 ScilabInteger aMatrix = new ScilabInteger(a, true);
159                 ScilabInteger bMatrix = new ScilabInteger(b, true);
160                 ScilabInteger cMatrix = new ScilabInteger(c, true);
161                 ScilabInteger dMatrix = new ScilabInteger(c, false);
162                 assert aMatrix.equals(bMatrix) == true;
163                 assert bMatrix.equals(aMatrix) == true;
164                 assert cMatrix.equals(aMatrix) == false;
165                 assert cMatrix.equals(dMatrix) == true;
166                 assert aMatrix.getType() == ScilabTypeEnum.sci_ints;
167                 assert bMatrix.getType() == ScilabTypeEnum.sci_ints;
168                 assert cMatrix.getType() == ScilabTypeEnum.sci_ints;
169                 
170                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
171                 assert aMatrix.toString().equals("uint8([32, 42, 41 ; 12, 13, 32])") == true;
172                 assert cMatrix.toString().equals("uint8([42, 43 ; 21, 22])") == true;
173                 assert dMatrix.toString().equals("int8([42, 43 ; 21, 22])") == true;
174                 assert aMatrix.getDataAsByte().length == a.length;
175                 assert aMatrix.getDataAsByte()[0].length == a[0].length;
176                 byte [][]d = aMatrix.getDataAsByte();
177                 long [][]d2 = aMatrix.getData();
178                 assert d[0][0] == 32;
179                 assert d2[0][0] == 32;
180                 assert Arrays.deepEquals(a,d);
181                 assert aMatrix.getPrec() == ScilabIntegerTypeEnum.sci_uint8;
182                 assert dMatrix.getPrec() == ScilabIntegerTypeEnum.sci_int8;
183                 assert aMatrix.isUnsigned() == true;
184                 assert dMatrix.isUnsigned() == false;
185                 assert ScilabInteger.convertOldType("TYPE8", true) == ScilabIntegerTypeEnum.sci_uint8;
186                 assert ScilabInteger.convertOldType("TYPE8", false) == ScilabIntegerTypeEnum.sci_int8;
187         }
188
189
190         @Test
191         public void integer8MatrixTests() {
192                 byte [][]a={{21, 22, 42, 39},{23, 24, 44, 40}};
193                 ScilabInteger emptyMatrix = new ScilabInteger();
194                 assert emptyMatrix.getHeight() == 0;
195                 assert emptyMatrix.getWidth() == 0;
196                 assert emptyMatrix.isEmpty() == true;
197                 assert emptyMatrix.toString().equals("int([])") == true;
198                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
199                 emptyMatrix.setData(a, true);
200                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
201
202                 ScilabBoolean aMatrix = new ScilabBoolean(true);
203                 assert aMatrix.equals(emptyMatrix) == false;
204                 assert emptyMatrix.equals(aMatrix) == false;
205                 ScilabInteger scalarInteger = new ScilabInteger((byte)2);
206         }
207
208
209         @Test
210         public void compareInteger16Test() throws NullPointerException {
211                 short [][]a={{32,42,41}, {12,13,32}};
212                 short [][]b={{32,42,41}, {12,13,32}};
213                 short [][]c={{42,43},{21,22}};
214                 ScilabInteger aMatrix = new ScilabInteger(a, true);
215                 ScilabInteger bMatrix = new ScilabInteger(b, true);
216                 ScilabInteger cMatrix = new ScilabInteger(c, true);
217                 ScilabInteger dMatrix = new ScilabInteger(c, false);
218                 assert aMatrix.equals(bMatrix) == true;
219                 assert bMatrix.equals(aMatrix) == true;
220                 assert cMatrix.equals(aMatrix) == false;
221                 assert cMatrix.equals(dMatrix) == true;
222                 assert aMatrix.getType() == ScilabTypeEnum.sci_ints;
223                 assert bMatrix.getType() == ScilabTypeEnum.sci_ints;
224                 assert cMatrix.getType() == ScilabTypeEnum.sci_ints;
225
226                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
227                 assert aMatrix.toString().equals("uint16([32, 42, 41 ; 12, 13, 32])") == true;
228                 assert cMatrix.toString().equals("uint16([42, 43 ; 21, 22])") == true;
229                 assert dMatrix.toString().equals("int16([42, 43 ; 21, 22])") == true;
230                 assert aMatrix.getDataAsShort().length == a.length;
231                 assert aMatrix.getDataAsShort()[0].length == a[0].length;
232                 short [][]d = aMatrix.getDataAsShort();
233                 long [][]d2 = aMatrix.getData();
234                 assert d[0][0] == 32;
235                 assert d2[0][0] == 32;
236                 assert Arrays.deepEquals(a,d);
237                 assert aMatrix.getPrec() == ScilabIntegerTypeEnum.sci_uint16;
238                 assert dMatrix.getPrec() == ScilabIntegerTypeEnum.sci_int16;
239                 assert aMatrix.isUnsigned() == true;
240                 assert dMatrix.isUnsigned() == false;
241                 assert ScilabInteger.convertOldType("TYPE16", true) == ScilabIntegerTypeEnum.sci_uint16;
242                 assert ScilabInteger.convertOldType("TYPE16", false) == ScilabIntegerTypeEnum.sci_int16;
243         }
244
245         @Test
246         public void integer16MatrixTests() {
247                 short [][]a={{21, 22, 42, 39},{23, 24, 44, 40}};
248                 ScilabInteger emptyMatrix = new ScilabInteger();
249                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
250                 emptyMatrix.setData(a, true);
251                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
252
253                 ScilabBoolean aMatrix = new ScilabBoolean(true);
254                 assert aMatrix.equals(emptyMatrix) == false;
255                 assert emptyMatrix.equals(aMatrix) == false;
256                 ScilabInteger scalarInteger = new ScilabInteger((short)2);
257         }
258
259         @Test
260         public void compareInteger32Test() throws NullPointerException {
261                 int [][]a={{32,42,41}, {12,13,32}};
262                 int [][]b={{32,42,41}, {12,13,32}};
263                 int [][]c={{42,43},{21,22}};
264                 ScilabInteger aMatrix = new ScilabInteger(a, true);
265                 ScilabInteger bMatrix = new ScilabInteger(b, true);
266                 ScilabInteger cMatrix = new ScilabInteger(c, true);
267                 ScilabInteger dMatrix = new ScilabInteger(c, false);
268                 assert aMatrix.equals(bMatrix) == true;
269                 assert bMatrix.equals(aMatrix) == true;
270                 assert cMatrix.equals(aMatrix) == false;
271                 assert cMatrix.equals(dMatrix) == true;
272                 assert aMatrix.getType() == ScilabTypeEnum.sci_ints;
273                 assert bMatrix.getType() == ScilabTypeEnum.sci_ints;
274                 assert cMatrix.getType() == ScilabTypeEnum.sci_ints;
275
276                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
277                 assert aMatrix.toString().equals("uint32([32, 42, 41 ; 12, 13, 32])") == true;
278                 assert cMatrix.toString().equals("uint32([42, 43 ; 21, 22])") == true;
279                 assert dMatrix.toString().equals("int32([42, 43 ; 21, 22])") == true;
280                 assert aMatrix.getDataAsInt().length == a.length;
281                 assert aMatrix.getDataAsInt()[0].length == a[0].length;
282                 int [][]d = aMatrix.getDataAsInt();
283                 long [][]d2 = aMatrix.getData();
284                 assert d[0][0] == 32;
285                 assert d2[0][0] == 32;
286                 assert Arrays.deepEquals(a,d);
287                 assert aMatrix.getPrec() == ScilabIntegerTypeEnum.sci_uint32;
288                 assert dMatrix.getPrec() == ScilabIntegerTypeEnum.sci_int32;
289                 assert aMatrix.isUnsigned() == true;
290                 assert dMatrix.isUnsigned() == false;
291                 assert ScilabInteger.convertOldType("TYPE32", true) == ScilabIntegerTypeEnum.sci_uint32;
292                 assert ScilabInteger.convertOldType("TYPE32", false) == ScilabIntegerTypeEnum.sci_int32;
293         }
294
295         @Test
296         public void integer32MatrixTests() {
297                 int [][]a={{21, 22, 42, 39},{23, 24, 44, 40}};
298                 ScilabInteger emptyMatrix = new ScilabInteger();
299                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
300                 emptyMatrix.setData(a, true);
301                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
302
303                 ScilabBoolean aMatrix = new ScilabBoolean(true);
304                 assert aMatrix.equals(emptyMatrix) == false;
305                 assert emptyMatrix.equals(aMatrix) == false;
306                 ScilabInteger scalarInteger = new ScilabInteger((int)2);
307         }
308
309         @Test
310         public void compareInteger64Test() throws NullPointerException {
311                 long [][]a={{32,42,41}, {12,13,32}};
312                 long [][]b={{32,42,41}, {12,13,32}};
313                 long [][]c={{42,43},{21,22}};
314                 ScilabInteger aMatrix = new ScilabInteger(a, true);
315                 ScilabInteger bMatrix = new ScilabInteger(b, true);
316                 ScilabInteger cMatrix = new ScilabInteger(c, true);
317                 ScilabInteger dMatrix = new ScilabInteger(c, false);
318                 assert aMatrix.equals(bMatrix) == true;
319                 assert bMatrix.equals(aMatrix) == true;
320                 assert cMatrix.equals(aMatrix) == false;
321                 assert cMatrix.equals(dMatrix) == true;
322                 assert aMatrix.getType() == ScilabTypeEnum.sci_ints;
323                 assert bMatrix.getType() == ScilabTypeEnum.sci_ints;
324                 assert cMatrix.getType() == ScilabTypeEnum.sci_ints;
325
326                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
327                 assert aMatrix.toString().equals("uint64([32, 42, 41 ; 12, 13, 32])") == true;
328                 assert cMatrix.toString().equals("uint64([42, 43 ; 21, 22])") == true;
329                 assert dMatrix.toString().equals("int64([42, 43 ; 21, 22])") == true;
330                 assert aMatrix.getDataAsLong().length == a.length;
331                 assert aMatrix.getDataAsLong()[0].length == a[0].length;
332                 long [][]d = aMatrix.getDataAsLong();
333                 long [][]d2 = aMatrix.getData();
334                 assert d[0][0] == 32;
335                 assert d2[0][0] == 32;
336                 assert Arrays.deepEquals(a,d);
337                 assert aMatrix.getPrec() == ScilabIntegerTypeEnum.sci_uint64;
338                 assert dMatrix.getPrec() == ScilabIntegerTypeEnum.sci_int64;
339                 assert aMatrix.isUnsigned() == true;
340                 assert dMatrix.isUnsigned() == false;
341                 assert ScilabInteger.convertOldType("TYPE64", true) == ScilabIntegerTypeEnum.sci_uint64;
342                 assert ScilabInteger.convertOldType("TYPE64", false) == ScilabIntegerTypeEnum.sci_int64;
343         }
344
345         @Test
346         public void integer64MatrixTests() {
347                 long [][]a={{21, 22, 42, 39},{23, 24, 44, 40}};
348                 ScilabInteger emptyMatrix = new ScilabInteger();
349                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
350                 emptyMatrix.setData(a, true);
351                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_ints;
352
353                 ScilabBoolean aMatrix = new ScilabBoolean(true);
354                 assert aMatrix.equals(emptyMatrix) == false;
355                 assert emptyMatrix.equals(aMatrix) == false;
356                 ScilabInteger scalarInteger = new ScilabInteger((long)2);
357         }
358
359
360         @Test
361         public void compareBooleanTest() throws NullPointerException {
362                 boolean [][]a={{true,false,true}, {true,true,true}};
363                 boolean [][]b={{true,false,true}, {true,true,true}};
364                 boolean [][]c={{true,false},{false,true}};
365                 ScilabBoolean aMatrix = new ScilabBoolean(a);
366                 ScilabBoolean bMatrix = new ScilabBoolean(b);
367                 ScilabBoolean cMatrix = new ScilabBoolean(c);
368                 assert aMatrix.equals(bMatrix) == true;
369                 assert bMatrix.equals(aMatrix) == true;
370                 assert cMatrix.equals(aMatrix) == false;
371                 assert aMatrix.getType() == ScilabTypeEnum.sci_boolean;
372                 assert bMatrix.getType() == ScilabTypeEnum.sci_boolean;
373                 assert cMatrix.getType() == ScilabTypeEnum.sci_boolean;
374
375                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
376                 assert aMatrix.toString().equals("[%t, %f, %t ; %t, %t, %t]") == true;
377                 assert cMatrix.toString().equals("[%t, %f ; %f, %t]") == true;
378         }
379
380         @Test
381         public void booleanMatrixTests() {
382                 boolean [][]a={{true,false,true}, {true,true,true}};
383                 ScilabBoolean emptyMatrix = new ScilabBoolean();
384                 assert emptyMatrix.getHeight() == 0;
385                 assert emptyMatrix.getWidth() == 0;
386                 assert emptyMatrix.isEmpty() == true;
387                 assert emptyMatrix.toString().equals("[]") == true;
388                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_boolean;
389                 emptyMatrix.setData(a);
390                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_boolean;
391
392                 ScilabDouble aMatrix = new ScilabDouble(2);
393                 assert aMatrix.equals(emptyMatrix) == false;
394                 assert emptyMatrix.equals(aMatrix) == false;
395         }
396
397         @Test
398         public void compareStringTest() throws NullPointerException {
399                 String [][]a={{"This","is","my","string"},{"and","I want to", "compare"," them"}};
400                 String [][]b={{"This","is","my","string"},{"and","I want to", "compare"," them"}};
401                 String [][]c={{"Wrong","string"},{"right","string"}};
402                 ScilabString aMatrix = new ScilabString(a);
403                 ScilabString bMatrix = new ScilabString(b);
404                 ScilabString cMatrix = new ScilabString(c);
405                 assert aMatrix.equals(bMatrix) == true;
406                 assert bMatrix.equals(aMatrix) == true;
407                 assert cMatrix.equals(aMatrix) == false;
408                 assert aMatrix.getType() == ScilabTypeEnum.sci_strings;
409                 assert bMatrix.getType() == ScilabTypeEnum.sci_strings;
410                 assert cMatrix.getType() == ScilabTypeEnum.sci_strings;
411
412                 assert Arrays.deepEquals(aMatrix.getData(), bMatrix.getData()) == true;
413                 assert aMatrix.toString().equals("[\"This\", \"is\", \"my\", \"string\" ; \"and\", \"I want to\", \"compare\", \" them\"]") == true;
414                 assert cMatrix.toString().equals("[\"Wrong\", \"string\" ; \"right\", \"string\"]") == true;
415
416         }
417
418         @Test(expectedExceptions = IllegalArgumentException.class)
419         public void stringMatrixTests() {
420                 String [][]a={{"This","is","my","string"},{"and","I want to", "compare"," them"}};
421                 ScilabString emptyMatrix = new ScilabString();
422                 assert emptyMatrix.getHeight() == 0;
423                 assert emptyMatrix.getWidth() == 0;
424                 assert emptyMatrix.isEmpty() == true;
425                 assert emptyMatrix.toString().equals("[]") == true;
426                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_strings;
427                 emptyMatrix.setData(a);
428                 assert emptyMatrix.getType() == ScilabTypeEnum.sci_strings;
429                 ScilabDouble aMatrix = new ScilabDouble(2);
430                 assert aMatrix.equals(emptyMatrix) == false;
431                 assert emptyMatrix.equals(aMatrix) == false;
432                 String []b={"This","is","my","string"};
433                 ScilabString vectorString = new ScilabString(b);
434                 String []c = null;
435                 ScilabString emptyString = new ScilabString(c);
436                 ScilabString nullString = new ScilabString((String)null);
437
438         }
439
440         @Test
441         public void compareListTest() throws NullPointerException {
442                 ScilabList data = new ScilabList();
443                 assert data.getType() == ScilabTypeEnum.sci_list;
444                 assert data.getHeight() == 0;
445                 assert data.getWidth() == 0;
446                 assert data.toString().equals("list()");
447                 data.add(new ScilabDouble(2));
448                 assert data.getHeight() == 1;
449                 assert data.getWidth() == 1;
450                 data.add(new ScilabDouble(51));
451                 assert data.getHeight() == 1;
452                 assert data.getWidth() == 2;
453                 data.add(new ScilabString("hello"));
454                 ScilabList data2 = new ScilabList();
455                 data2.add(new ScilabDouble(2));
456                 data2.add(new ScilabDouble(51));
457                 data2.add(new ScilabString("hello"));
458                 ScilabList data3 = new ScilabList();
459                 data3.add(new ScilabDouble(2));
460                 data3.add(new ScilabDouble(42));
461                 data3.add(new ScilabBoolean(true));
462                 data3.add(new ScilabString("hello"));
463                 assert data.equals(data2) == true;
464                 assert data.equals(data3) == false;
465                 assert data.toString().equals("list([2.0], [51.0], [\"hello\"])") == true;
466                 assert data3.toString().equals("list([2.0], [42.0], [%t], [\"hello\"])") == true;
467
468                 ScilabList data4 = new ScilabList(data3);
469                 assert data4.equals(data3) == true;
470                 assert data4.getType() == ScilabTypeEnum.sci_list;
471
472         }
473
474
475         @Test
476         public void compareTListTest() throws NullPointerException {
477                 ScilabTList data = new ScilabTList();
478                 assert data.getType() == ScilabTypeEnum.sci_tlist;
479                 assert data.getHeight() == 0;
480                 assert data.getWidth() == 0;
481                 assert data.toString().equals("tlist()");
482                 data.add(new ScilabString("hello"));
483                 assert data.getHeight() == 1;
484                 assert data.getWidth() == 1;
485                 data.add(new ScilabDouble(2));
486                 assert data.getHeight() == 1;
487                 assert data.getWidth() == 2;
488                 data.add(new ScilabDouble(51));
489                 assert data.getHeight() == 1;
490                 assert data.getWidth() == 3;
491                 ScilabTList data2 = new ScilabTList();
492                 data2.add(new ScilabString("hello"));
493                 data2.add(new ScilabDouble(2));
494                 data2.add(new ScilabDouble(51));
495                 ScilabTList data3 = new ScilabTList();
496                 data3.add(new ScilabString("hello"));
497                 data3.add(new ScilabDouble(2));
498                 data3.add(new ScilabDouble(42));
499                 data3.add(new ScilabBoolean(true));
500                 assert data.equals(data2) == true;
501                 assert data.equals(data3) == false;
502
503                 assert data.toString().equals("tlist([\"hello\"], [2.0], [51.0])") == true;
504                 assert data3.toString().equals("tlist([\"hello\"], [2.0], [42.0], [%t])") == true;
505                 String []b={"a","b","c"};
506
507                 ScilabTList tlist = new ScilabTList(b);
508                 tlist.add(new ScilabDouble(2));
509                 tlist.add(new ScilabDouble(3));
510                 assert tlist.toString().equals("tlist([\"a\", \"b\", \"c\"], [2.0], [3.0])") == true;
511                 ScilabTList tlistFromAnOther = new ScilabTList(b, data2);
512                 assert tlistFromAnOther.getHeight() == 1;
513                 assert tlistFromAnOther.getWidth() == 4;
514                 assert tlistFromAnOther.toString().equals("tlist([\"a\", \"b\", \"c\"], [\"hello\"], [2.0], [51.0])");
515                 assert tlist.getType() == ScilabTypeEnum.sci_tlist;
516         }
517
518
519         @Test
520         public void compareMListTest() throws NullPointerException {
521                 ScilabMList data = new ScilabMList();
522                 assert data.getType() == ScilabTypeEnum.sci_mlist;
523                 assert data.getHeight() == 0;
524                 assert data.getWidth() == 0;
525                 assert data.toString().equals("mlist()");
526                 data.add(new ScilabString("hello"));
527                 assert data.getHeight() == 1;
528                 assert data.getWidth() == 1;
529                 data.add(new ScilabDouble(2));
530                 assert data.getHeight() == 1;
531                 assert data.getWidth() == 2;
532                 data.add(new ScilabDouble(51));
533                 assert data.getHeight() == 1;
534                 assert data.getWidth() == 3;
535                 ScilabMList data2 = new ScilabMList();
536                 data2.add(new ScilabString("hello"));
537                 data2.add(new ScilabDouble(2));
538                 data2.add(new ScilabDouble(51));
539                 ScilabMList data3 = new ScilabMList();
540                 data3.add(new ScilabString("hello"));
541                 data3.add(new ScilabDouble(2));
542                 data3.add(new ScilabDouble(42));
543                 data3.add(new ScilabBoolean(true));
544                 assert data3.getType() == ScilabTypeEnum.sci_mlist;
545                 assert data.equals(data2) == true;
546                 assert data.equals(data3) == false;
547                 assert data.toString().equals("mlist([\"hello\"], [2.0], [51.0])") == true;
548                 assert data3.toString().equals("mlist([\"hello\"], [2.0], [42.0], [%t])") == true;
549                 String []b={"a","b","c"};
550
551                 ScilabMList mlist = new ScilabMList(b);
552                 mlist.add(new ScilabDouble(2));
553                 mlist.add(new ScilabDouble(3));
554                 assert mlist.toString().equals("mlist([\"a\", \"b\", \"c\"], [2.0], [3.0])") == true;
555                 ScilabMList mlistFromAnOther = new ScilabMList(b, data2);
556                 assert mlistFromAnOther.getHeight() == 1;
557                 assert mlistFromAnOther.getWidth() == 4;
558                 assert mlistFromAnOther.toString().equals("mlist([\"a\", \"b\", \"c\"], [\"hello\"], [2.0], [51.0])");
559
560         }
561
562
563 }