src/test/java/jp/sourceforge/jovsonz/JsArrayTest.java

   1 /*
   2  * License : The MIT License
   3  * Copyright(c) 2009 olyutorskii
   4  */
   5
   6 package jp.sourceforge.jovsonz;
   7
   8 import java.util.Iterator;
   9 import java.util.LinkedList;
  10 import java.util.List;
  11 import org.junit.After;
  12 import org.junit.AfterClass;
  13 import org.junit.Before;
  14 import org.junit.BeforeClass;
  15 import org.junit.Test;
  16
  17 import static org.junit.Assert.*;
  18
  19 /**
  20  *
  21  */
  22 public class JsArrayTest {
  23
  24     public JsArrayTest() {
  25     }
  26
  27     @BeforeClass
  28     public static void setUpClass() throws Exception{
  29     }
  30
  31     @AfterClass
  32     public static void tearDownClass() throws Exception{
  33     }
  34
  35     @Before
  36     public void setUp() {
  37     }
  38
  39     @After
  40     public void tearDown() {
  41     }
  42
  43     /**
  44      * Test of parseArray method, of class JsArray.
  45      */
  46     @Test
  47     public void testParseArray() throws Exception{
  48         System.out.println("parseArray");
  49
  50         JsonSource source;
  51         JsArray array;
  52
  53         source = new JsonSource("[]");
  54         array = JsArray.parseArray(source);
  55         assertEquals(0, array.size());
  56
  57         source = new JsonSource("[true]");
  58         array = JsArray.parseArray(source);
  59         assertEquals(1, array.size());
  60         assertEquals(JsBoolean.TRUE, array.get(0));
  61
  62         source = new JsonSource("[true,false]");
  63         array = JsArray.parseArray(source);
  64         assertEquals(2, array.size());
  65         assertEquals(JsBoolean.TRUE, array.get(0));
  66         assertEquals(JsBoolean.FALSE, array.get(1));
  67
  68         source = new JsonSource("\n[\rtrue\t, false\n]\r");
  69         array = JsArray.parseArray(source);
  70         assertNull(array);
  71
  72         source = new JsonSource("[\rtrue\t, false\n]\r");
  73         array = JsArray.parseArray(source);
  74         assertEquals(2, array.size());
  75         assertEquals(JsBoolean.TRUE, array.get(0));
  76         assertEquals(JsBoolean.FALSE, array.get(1));
  77
  78         try{
  79             source = new JsonSource("[,]");
  80             array = JsArray.parseArray(source);
  81             fail();
  82         }catch(JsParseException e){
  83             // NOTHING
  84         }
  85
  86         try{
  87             source = new JsonSource("[true,]");
  88             array = JsArray.parseArray(source);
  89             fail();
  90         }catch(JsParseException e){
  91             // NOTHING
  92         }
  93
  94         try{
  95             source = new JsonSource("[true#]");
  96             array = JsArray.parseArray(source);
  97             fail();
  98         }catch(JsParseException e){
  99             // NOTHING
 100         }
 101
 102         try{
 103             source = new JsonSource("[true,");
 104             array = JsArray.parseArray(source);
 105             fail();
 106         }catch(JsParseException e){
 107             // NOTHING
 108         }
 109
 110         try{
 111             source = new JsonSource("[true");
 112             array = JsArray.parseArray(source);
 113             fail();
 114         }catch(JsParseException e){
 115             // NOTHING
 116         }
 117
 118         source = new JsonSource("true]");
 119         array = JsArray.parseArray(source);
 120         assertNull(array);
 121
 122         return;
 123     }
 124
 125     /**
 126      * Test of add method, of class JsArray.
 127      */
 128     @Test
 129     public void testAdd(){
 130         System.out.println("add");
 131
 132         JsArray array = new JsArray();
 133
 134         JsNumber number = new JsNumber("1.23");
 135         assertEquals(0, array.size());
 136         array.add(number);
 137         assertEquals(1, array.size());
 138         array.add(number);
 139         assertEquals(2, array.size());
 140
 141         return;
 142     }
 143
 144     /**
 145      * Test of get method, of class JsArray.
 146      */
 147     @Test
 148     public void testGet(){
 149         System.out.println("get");
 150
 151         JsArray array = new JsArray();
 152
 153         JsValue val1 = new JsNumber("1.23");
 154         JsValue val2 = new JsString("abc");
 155
 156         array.add(val1);
 157         array.add(val2);
 158
 159         assertEquals(val1, array.get(0));
 160         assertEquals(val2, array.get(1));
 161
 162         try{
 163             array.get(2);
 164             fail();
 165         }catch(IndexOutOfBoundsException e){
 166             // NOTHING
 167         }
 168
 169         return;
 170     }
 171
 172     /**
 173      * Test of clear method, of class JsArray.
 174      */
 175     @Test
 176     public void testClear(){
 177         System.out.println("clear");
 178
 179         JsArray array = new JsArray();
 180
 181         JsValue val1 = new JsNumber("1.23");
 182         JsValue val2 = new JsString("abc");
 183
 184         array.add(val1);
 185         array.add(val2);
 186         assertEquals(2, array.size());
 187
 188         array.clear();
 189         assertEquals(0, array.size());
 190
 191         try{
 192             array.get(0);
 193             fail();
 194         }catch(IndexOutOfBoundsException e){
 195             // NOTHING
 196         }
 197
 198         array = new JsArray();
 199         array.add(JsNull.NULL);
 200         assertEquals(1, array.size());
 201         assertTrue(array.hasChanged());
 202         array.setUnchanged();
 203         assertFalse(array.hasChanged());
 204         array.clear();
 205         assertEquals(0, array.size());
 206         assertTrue(array.hasChanged());
 207         array.setUnchanged();
 208         array.clear();
 209         assertEquals(0, array.size());
 210         assertFalse(array.hasChanged());
 211
 212         return;
 213     }
 214
 215     /**
 216      * Test of remove method, of class JsArray.
 217      */
 218     @Test
 219     public void testRemove_JsValue(){
 220         System.out.println("remove");
 221
 222         JsArray array = new JsArray();
 223
 224         JsValue val1 = new JsNumber("1.23");
 225         JsValue val2 = new JsString("abc");
 226         JsValue val3 = JsBoolean.TRUE;
 227
 228         array.add(val1);
 229         array.add(val2);
 230         assertEquals(2, array.size());
 231
 232         assertTrue(array.remove(val1));
 233         assertEquals(1, array.size());
 234         assertEquals(val2, array.get(0));
 235
 236         assertFalse(array.remove(val3));
 237         assertEquals(1, array.size());
 238
 239         return;
 240     }
 241
 242     /**
 243      * Test of remove method, of class JsArray.
 244      */
 245     @Test
 246     public void testRemove_int(){
 247         System.out.println("remove");
 248
 249         JsArray array = new JsArray();
 250
 251         JsValue val1 = new JsNumber("1.23");
 252         JsValue val2 = new JsString("abc");
 253         JsValue val3 = JsBoolean.TRUE;
 254
 255         array.add(val1);
 256         array.add(val2);
 257         array.add(val3);
 258         assertEquals(3, array.size());
 259
 260         assertEquals(val1, array.remove(0));
 261         assertEquals(2, array.size());
 262         assertEquals(val2, array.get(0));
 263
 264         assertEquals(val3, array.remove(1));
 265         assertEquals(1, array.size());
 266         assertEquals(val2, array.get(0));
 267
 268         return;
 269     }
 270
 271     /**
 272      * Test of size method, of class JsArray.
 273      */
 274     @Test
 275     public void testSize(){
 276         System.out.println("size");
 277
 278         JsArray array = new JsArray();
 279         assertEquals(0, array.size());
 280         assertTrue(array.isEmpty());
 281
 282         JsValue val1 = new JsNumber("1.23");
 283
 284         array.add(val1);
 285         assertEquals(1, array.size());
 286         assertFalse(array.isEmpty());
 287
 288         return;
 289     }
 290
 291     /**
 292      * Test of iterator method, of class JsArray.
 293      */
 294     @Test
 295     public void testIterator(){
 296         System.out.println("iterator");
 297
 298         JsArray array = new JsArray();
 299
 300         JsValue val1 = new JsNumber("1.23");
 301         JsValue val2 = new JsString("abc");
 302
 303         array.add(val1);
 304         array.add(val2);
 305
 306         Iterator<JsValue> it = array.iterator();
 307
 308         assertTrue(it.hasNext());
 309         assertEquals(val1, it.next());
 310
 311         assertTrue(it.hasNext());
 312         assertEquals(val2, it.next());
 313
 314         assertFalse(it.hasNext());
 315
 316         return;
 317     }
 318
 319     /**
 320      * Test of hashCode method, of class JsArray.
 321      */
 322     @Test
 323     public void testHashCode(){
 324         System.out.println("hashCode");
 325
 326         JsArray array1 = new JsArray();
 327         JsArray array2 = new JsArray();
 328
 329         assertEquals(array1.hashCode(), array2.hashCode());
 330
 331         array1.add(new JsString("abc"));
 332         array2.add(new JsString("abc"));
 333
 334         assertEquals(array1.hashCode(), array2.hashCode());
 335
 336         return;
 337     }
 338
 339     /**
 340      * Test of equals method, of class JsArray.
 341      */
 342     @Test
 343     public void testEquals(){
 344         System.out.println("equals");
 345
 346         JsArray array1 = new JsArray();
 347         JsArray array2 = new JsArray();
 348
 349         assertTrue(array1.equals(array2));
 350
 351         array1.add(new JsString("abc"));
 352         array2.add(new JsString("abc"));
 353
 354         assertTrue(array1.equals(array2));
 355
 356         array1.add(new JsString("xyz"));
 357         array2.add(new JsString("XYZ"));
 358
 359         assertFalse(array1.equals(array2));
 360
 361         JsArray nullVal = null;
 362
 363         assertFalse(array1.equals(nullVal));
 364
 365         assertFalse(array1.equals(""));
 366
 367         return;
 368     }
 369
 370     /**
 371      * Test of toString method, of class JsArray.
 372      */
 373     @Test
 374     public void testToString(){
 375         System.out.println("toString");
 376
 377         JsArray array = new JsArray();
 378
 379         assertEquals("[]", array.toString());
 380
 381         array.add(JsBoolean.TRUE);
 382         assertEquals("[true]", array.toString());
 383
 384         array.add(JsBoolean.FALSE);
 385         assertEquals("[true,false]", array.toString());
 386
 387         array.add(new JsArray());
 388         assertEquals("[true,false,[]]", array.toString());
 389
 390         return;
 391     }
 392
 393     /**
 394      * Test of traverse method, of class JsArray.
 395      */
 396     @Test
 397     public void testTraverse() throws Exception{
 398         System.out.println("traverse");
 399
 400         JsArray array = new JsArray();
 401         JsValue val1 = new JsNumber("12");
 402         JsValue val2 = new JsString("AB");
 403         array.add(val1);
 404         array.add(val2);
 405
 406         final List<Object> visited = new LinkedList<Object>();
 407
 408         try{
 409             array.traverse(new ValueVisitor(){
 410                 public void visitValue(JsValue value)
 411                         throws JsVisitException{
 412                     visited.add(value);
 413                     return;
 414                 }
 415
 416                 public void visitPairName(String name)
 417                         throws JsVisitException{
 418                     visited.add(name);
 419                     return;
 420                 }
 421
 422                 public void visitCompositionClose(JsComposition composite)
 423                         throws JsVisitException{
 424                     visited.add(composite);
 425                     return;
 426                 }
 427             });
 428         }catch(JsVisitException e){
 429             fail();
 430         }
 431
 432         assertEquals(4, visited.size());
 433         assertEquals(array, visited.get(0));
 434         assertEquals(val1, visited.get(1));
 435         assertEquals(val2, visited.get(2));
 436         assertEquals(array, visited.get(3));
 437
 438         return;
 439     }
 440
 441     /**
 442      * Test of hasChanged method, of class JsArray.
 443      */
 444     @Test
 445     public void testHasChanged(){
 446         System.out.println("hasChanged");
 447
 448         JsArray array = new JsArray();
 449         assertFalse(array.hasChanged());
 450
 451         array.add(new JsNumber("0"));
 452         assertTrue(array.hasChanged());
 453
 454         array.setUnchanged();
 455         assertFalse(array.hasChanged());
 456
 457         JsArray child = new JsArray();
 458         array.add(child);
 459         array.setUnchanged();
 460         assertFalse(array.hasChanged());
 461
 462         child.add(JsNull.NULL);
 463         assertTrue(array.hasChanged());
 464         array.setUnchanged();
 465         assertFalse(array.hasChanged());
 466
 467         return;
 468     }
 469
 470     /**
 471      * Test of setUnchanged method, of class JsArray.
 472      */
 473     @Test
 474     public void testSetUnchanged(){
 475         System.out.println("setUnchanged");
 476
 477         JsArray array = new JsArray();
 478         JsArray child = new JsArray();
 479         array.add(child);
 480
 481         child.add(JsNull.NULL);
 482         assertTrue(child.hasChanged());
 483
 484         array.setUnchanged();
 485         assertFalse(child.hasChanged());
 486
 487         return;
 488     }
 489
 490     /**
 491      * Test of getJsTypes method, of class JsArray.
 492      */
 493     @Test
 494     public void testGetJsTypes() {
 495         System.out.println("getJsTypes");
 496
 497         JsArray instance = new JsArray();
 498
 499         assertEquals(JsTypes.ARRAY, instance.getJsTypes());
 500
 501         return;
 502     }
 503
 504 }