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