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