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

   1 /*
   2  * License : The MIT License
   3  * Copyright(c) 2009 olyutorskii
   4  */
   5
   6 package jp.sourceforge.jovsonz;
   7
   8 import java.io.IOException;
   9 import java.io.Reader;
  10 import java.io.StringReader;
  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 JsonSourceTest {
  23
  24     public JsonSourceTest() {
  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 constructor, of class JsonSource.
  45      */
  46     @Test
  47     public void testConstructor() throws Exception{
  48         System.out.println("constructor");
  49
  50         JsonSource source;
  51         Reader reader;
  52
  53         reader = new StringReader("abc");
  54         source = new JsonSource(reader);
  55         assertEquals('a', source.read());
  56         assertEquals('b', source.read());
  57         assertEquals('c', source.read());
  58         assertEquals(-1, source.read());
  59
  60         source = new JsonSource("abc");
  61         assertEquals('a', source.read());
  62         assertEquals('b', source.read());
  63         assertEquals('c', source.read());
  64         assertEquals(-1, source.read());
  65
  66         try{
  67             source = new JsonSource((Reader)null);
  68             fail();
  69         }catch(NullPointerException e){
  70             //GOOD
  71         }
  72
  73         try{
  74             source = new JsonSource((String)null);
  75             fail();
  76         }catch(NullPointerException e){
  77             //GOOD
  78         }
  79
  80         return;
  81     }
  82
  83     /**
  84      * Test of getLineNumber method, of class JsonSource.
  85      */
  86     @Test
  87     public void testGetLineNumber() throws Exception{
  88         System.out.println("getLineNumber");
  89
  90         JsonSource source;
  91
  92         source = new JsonSource("a\nbc\r\nd\n\n");
  93         assertEquals(1, source.getLineNumber());
  94         assertEquals('a', source.read());
  95         assertEquals(1, source.getLineNumber());
  96         assertEquals('\n', source.read());
  97         assertEquals(2, source.getLineNumber());
  98         assertEquals('b', source.read());
  99         assertEquals(2, source.getLineNumber());
 100         assertEquals('c', source.read());
 101         assertEquals(2, source.getLineNumber());
 102         assertEquals('\r', source.read());
 103         assertEquals(2, source.getLineNumber());
 104         assertEquals('\n', source.read());
 105         assertEquals(3, source.getLineNumber());
 106         assertEquals('d', source.read());
 107         assertEquals(3, source.getLineNumber());
 108         assertEquals('\n', source.read());
 109         assertEquals(4, source.getLineNumber());
 110         assertEquals('\n', source.read());
 111         assertEquals(5, source.getLineNumber());
 112         assertEquals(-1, source.read());
 113         assertEquals(5, source.getLineNumber());
 114
 115         source = new JsonSource("\nX");
 116         assertEquals(1, source.getLineNumber());
 117         assertEquals('\n', source.read());
 118         assertEquals(2, source.getLineNumber());
 119         assertEquals('X', source.read());
 120         assertEquals(2, source.getLineNumber());
 121         assertEquals(-1, source.read());
 122         assertEquals(2, source.getLineNumber());
 123
 124         source = new JsonSource("");
 125         assertEquals(1, source.getLineNumber());
 126         assertEquals(-1, source.read());
 127
 128         return;
 129     }
 130
 131     /**
 132      * Test of read method, of class JsonSource.
 133      */
 134     @Test
 135     public void testRead() throws Exception{
 136         System.out.println("read");
 137
 138         JsonSource source;
 139         Reader reader;
 140
 141         reader = new StringReader("abc");
 142         source = new JsonSource(reader);
 143         assertEquals('a', source.read());
 144         assertEquals('b', source.read());
 145         assertEquals('c', source.read());
 146         assertEquals(-1, source.read());
 147
 148         source = new JsonSource("abc");
 149         assertEquals('a', source.read());
 150         assertEquals('b', source.read());
 151         assertEquals('c', source.read());
 152         assertEquals(-1, source.read());
 153
 154         source = new JsonSource("X\u0000\u3000\uffffZ");
 155         assertEquals('X', source.read());
 156         assertEquals('\u0000', source.read());
 157         assertEquals('\u3000', source.read());
 158         assertEquals('\uffff', source.read());
 159         assertEquals('Z', source.read());
 160         assertEquals(-1, source.read());
 161
 162         // CJK UNIFIED IDEOGRAPH-2000B 𠀋
 163         source = new JsonSource("X\ud840\udc0bZ");
 164         assertEquals('X', source.read());
 165         assertEquals('\ud840', source.read());
 166         assertEquals('\udc0b', source.read());
 167         assertEquals('Z', source.read());
 168         assertEquals(-1, source.read());
 169
 170         source = new JsonSource("");
 171         assertEquals(-1, source.read());
 172
 173         reader = new TroubleReader("abc", 1);
 174         source = new JsonSource(reader);
 175         assertEquals('a', source.read());
 176         try{
 177             source.read();
 178             fail();
 179         }catch(IOException e){
 180             // GOOD!
 181         }catch(Throwable e){
 182             fail();
 183         }
 184
 185         return;
 186     }
 187
 188     /**
 189      * Test of readOrDie method, of class JsonSource.
 190      */
 191     @Test
 192     public void testReadOrDie() throws Exception{
 193         System.out.println("readOrDie");
 194
 195         JsonSource source;
 196
 197         source = new JsonSource("ab\nc");
 198         assertEquals('a', source.readOrDie());
 199         assertEquals('b', source.readOrDie());
 200         assertEquals('\n', source.readOrDie());
 201         assertEquals('c', source.readOrDie());
 202         try{
 203             source.readOrDie();
 204             fail();
 205         }catch(JsParseException e){
 206             assertEquals(2, e.getLineNumber());
 207             assertEquals("We need but no more JSON data [line:2]",
 208                          e.getMessage());
 209         }catch(Throwable e){
 210             fail();
 211         }
 212
 213         Reader reader = new TroubleReader("abc", 1);
 214         source = new JsonSource(reader);
 215         assertEquals('a', source.readOrDie());
 216         try{
 217             source.readOrDie();
 218             fail();
 219         }catch(IOException e){
 220             // GOOD!
 221         }catch(Throwable e){
 222             fail();
 223         }
 224
 225         return;
 226     }
 227
 228     /**
 229      * Test of matchOrDie method, of class JsonSource.
 230      */
 231     @Test
 232     public void testMatchOrDie() throws Exception{
 233         System.out.println("matchOrDie");
 234
 235         JsonSource source;
 236
 237         source = new JsonSource("ABC");
 238         assertTrue(source.matchOrDie("ABC"));
 239
 240         source = new JsonSource("ABC");
 241         assertFalse(source.matchOrDie("XYZ"));
 242
 243         source = new JsonSource("ABC");
 244         assertTrue(source.matchOrDie("A"));
 245
 246         source = new JsonSource("ABC");
 247         assertTrue(source.matchOrDie(""));
 248
 249         source = new JsonSource("ABC");
 250         try{
 251             source.matchOrDie("ABCD");
 252             fail();
 253         }catch(JsParseException e){
 254             //GOOD
 255         }
 256
 257         return;
 258     }
 259
 260     /**
 261      * Test of unread method, of class JsonSource.
 262      */
 263     @Test
 264     public void testUnread() throws Exception{
 265         System.out.println("unread");
 266
 267         JsonSource source;
 268         Reader reader;
 269
 270         reader = new StringReader("abc");
 271         source = new JsonSource(reader);
 272         assertEquals('a', source.read());
 273         assertEquals('b', source.read());
 274         source.unread('X');
 275         source.unread('Y');
 276         assertEquals('Y', source.read());
 277         assertEquals('X', source.read());
 278         assertEquals('c', source.read());
 279         assertEquals(-1, source.read());
 280
 281         reader = new StringReader("a\nb\nc");
 282         source = new JsonSource(reader);
 283         assertEquals('a', source.read());
 284         assertEquals('\n', source.read());
 285         assertEquals('b', source.read());
 286         assertEquals('\n', source.read());
 287         assertEquals(3, source.getLineNumber());
 288         source.unread('\n');
 289         assertEquals(2, source.getLineNumber());
 290         assertEquals('\n', source.read());
 291         assertEquals(3, source.getLineNumber());
 292
 293         reader = new StringReader("abc");
 294         source = new JsonSource(reader);
 295         assertEquals('a', source.read());
 296         assertEquals('b', source.read());
 297         source.unread(-1);
 298         assertEquals((char)-1, source.read());
 299         assertEquals('c', source.read());
 300         assertEquals(-1, source.read());
 301
 302         reader = new StringReader("X");
 303         source = new JsonSource(reader);
 304         source.unread('Y');
 305         assertEquals('Y', source.read());
 306         assertEquals('X', source.read());
 307         assertEquals(-1, source.read());
 308
 309         reader = new StringReader("X");
 310         source = new JsonSource(reader);
 311         int spared = source.getPushBackSpared();
 312         for(int ct = 1; ct <= spared; ct++){
 313             source.unread('Y');
 314         }
 315         for(int ct = 1; ct <= spared; ct++){
 316             assertEquals('Y', source.read());
 317         }
 318         assertEquals('X', source.read());
 319         assertEquals(-1, source.read());
 320
 321         reader = new StringReader("X");
 322         source = new JsonSource(reader);
 323         while(source.getPushBackSpared() > 0){
 324             source.unread('Y');
 325         }
 326         try{
 327             source.unread('Y');
 328             fail();
 329         }catch(IOException e){
 330             assertEquals("Pushback buffer overflow", e.getMessage());
 331         }catch(Throwable e){
 332             fail();
 333         }
 334
 335         return;
 336     }
 337
 338     /**
 339      * Test of unread method, of class JsonSource.
 340      */
 341     @Test
 342     public void testUnread_int() throws Exception{
 343         System.out.println("unread");
 344
 345         JsonSource source;
 346         Reader reader;
 347
 348         reader = new StringReader("abc");
 349         source = new JsonSource(reader);
 350         assertEquals('a', source.readOrDie());
 351         assertEquals('b', source.readOrDie());
 352         source.unread((int) 'X');
 353         assertEquals('X', source.readOrDie());
 354         assertEquals('c', source.readOrDie());
 355         assertEquals(-1, source.read());
 356
 357         reader = new StringReader("");
 358         source = new JsonSource(reader);
 359         assertEquals(-1, source.read());
 360         source.unread((int) 'X');
 361         assertEquals('X', source.readOrDie());
 362
 363         reader = new StringReader("ab");
 364         source = new JsonSource(reader);
 365         assertEquals('a', source.readOrDie());
 366         source.unread((int) 'X');
 367         source.unread((int) 'Y');
 368         assertEquals('Y', source.readOrDie());
 369         assertEquals('X', source.readOrDie());
 370         assertEquals('b', source.readOrDie());
 371         assertEquals(-1, source.read());
 372
 373         reader = new StringReader("");
 374         source = new JsonSource(reader);
 375         source.unread((int) '\0');
 376         assertEquals('\0', source.readOrDie());
 377         source.unread(0xffff);
 378         assertEquals('\uffff', source.readOrDie());
 379         source.unread(0x1ffff);
 380         assertEquals('\uffff', source.readOrDie());
 381         source.unread(0x1ffff);
 382         assertEquals(0xffff, source.read());
 383         source.unread(0xffffffff);
 384         assertEquals(0xffff, source.read());
 385         source.unread(-1);
 386         assertEquals(0xffff, source.read());
 387
 388         source.unread(-1);
 389         assertEquals(0xffff, source.readOrDie());
 390
 391         return;
 392     }
 393
 394     /**
 395      * Test of unread method, of class JsonSource.
 396      */
 397     @Test
 398     public void testUnread_char() throws Exception{
 399         System.out.println("unread");
 400
 401         JsonSource source;
 402         Reader reader;
 403
 404         reader = new StringReader("abc");
 405         source = new JsonSource(reader);
 406         assertEquals('a', source.readOrDie());
 407         assertEquals('b', source.readOrDie());
 408         source.unread('X');
 409         assertEquals('X', source.readOrDie());
 410         assertEquals('c', source.readOrDie());
 411         assertEquals(-1, source.read());
 412
 413         reader = new StringReader("");
 414         source = new JsonSource(reader);
 415         assertEquals(-1, source.read());
 416         source.unread('X');
 417         assertEquals('X', source.readOrDie());
 418
 419         reader = new StringReader("ab");
 420         source = new JsonSource(reader);
 421         assertEquals('a', source.readOrDie());
 422         source.unread('X');
 423         source.unread('Y');
 424         assertEquals('Y', source.readOrDie());
 425         assertEquals('X', source.readOrDie());
 426         assertEquals('b', source.readOrDie());
 427         assertEquals(-1, source.read());
 428
 429         reader = new StringReader("");
 430         source = new JsonSource(reader);
 431         source.unread('\0');
 432         assertEquals('\0', source.readOrDie());
 433         source.unread((char) 0xffff);
 434         assertEquals('\uffff', source.readOrDie());
 435
 436         return;
 437     }
 438
 439     /**
 440      * Test of close method, of class JsonSource.
 441      */
 442     @Test
 443     public void testClose() throws Exception{
 444         System.out.println("close");
 445
 446         JsonSource source;
 447         Reader reader;
 448
 449         reader = new StringReader("abc");
 450         source = new JsonSource(reader);
 451         source.close();
 452
 453         try{
 454             source.read();
 455             fail();
 456         }catch(IOException e){
 457             assertEquals("Stream closed", e.getMessage());
 458         }
 459
 460         try{
 461             source.unread('X');
 462             fail();
 463         }catch(IOException e){
 464             assertEquals("Stream closed", e.getMessage());
 465         }
 466
 467         return;
 468     }
 469
 470     /**
 471      * Test of getPushBackSpared method, of class JsonSource.
 472      */
 473     @Test
 474     public void testGetPushBackSpared() throws Exception{
 475         System.out.println("getPushBackSpared");
 476
 477         JsonSource source;
 478         Reader reader;
 479
 480         reader = new StringReader("abc");
 481         source = new JsonSource(reader);
 482
 483         assertTrue(source.getPushBackSpared() > 0);
 484
 485         while(source.getPushBackSpared() > 0){
 486             source.unread('X');
 487         }
 488
 489         try{
 490             source.unread('X');
 491             fail();
 492         }catch(IOException e){
 493             //NOTHING
 494         }
 495
 496         assertEquals(0, source.getPushBackSpared());
 497         source.close();
 498         assertTrue(source.getPushBackSpared() > 0);
 499
 500         return;
 501     }
 502
 503     /**
 504      * Test of isWhitespace method, of class JsonSource.
 505      */
 506     @Test
 507     public void testIsWhitespace_char(){
 508         System.out.println("isWhitespace");
 509
 510         assertTrue(JsonSource.isWhitespace('\t'));
 511         assertTrue(JsonSource.isWhitespace('\r'));
 512         assertTrue(JsonSource.isWhitespace('\n'));
 513         assertTrue(JsonSource.isWhitespace('\u0020'));
 514
 515         assertFalse(JsonSource.isWhitespace('A'));
 516         assertFalse(JsonSource.isWhitespace('\u3000'));
 517         assertFalse(JsonSource.isWhitespace('\0'));
 518         assertFalse(JsonSource.isWhitespace((char) -1));
 519
 520         return;
 521     }
 522
 523     /**
 524      * Test of isWhitespace method, of class JsonSource.
 525      */
 526     @Test
 527     public void testIsWhitespace_int(){
 528         System.out.println("isWhitespace");
 529
 530         assertTrue(JsonSource.isWhitespace((int) '\t'));
 531         assertTrue(JsonSource.isWhitespace((int) '\r'));
 532         assertTrue(JsonSource.isWhitespace((int) '\n'));
 533         assertTrue(JsonSource.isWhitespace((int) '\u0020'));
 534         assertTrue(JsonSource.isWhitespace(0x0020));
 535
 536         assertFalse(JsonSource.isWhitespace((int) 'A'));
 537         assertFalse(JsonSource.isWhitespace((int) '\u3000'));
 538         assertFalse(JsonSource.isWhitespace((int) '\0'));
 539         assertFalse(JsonSource.isWhitespace(-1));
 540
 541         assertFalse(JsonSource.isWhitespace(0xffff));
 542         assertFalse(JsonSource.isWhitespace(0x1ffff));
 543         assertFalse(JsonSource.isWhitespace(0xffff0020));
 544
 545         return;
 546     }
 547
 548     /**
 549      * Test of skipWhiteSpace method, of class JsonSource.
 550      */
 551     @Test
 552     public void testSkipWhiteSpace() throws Exception{
 553         System.out.println("skipWhiteSpace");
 554
 555         JsonSource source;
 556         Reader reader;
 557
 558         reader = new StringReader("abc");
 559         source = new JsonSource(reader);
 560         source.skipWhiteSpace();
 561         assertEquals('a', source.read());
 562
 563         reader = new StringReader(" abc");
 564         source = new JsonSource(reader);
 565         source.skipWhiteSpace();
 566         assertEquals('a', source.read());
 567
 568         reader = new StringReader("\t\r\n\u0020abc");
 569         source = new JsonSource(reader);
 570         source.skipWhiteSpace();
 571         assertEquals('a', source.read());
 572
 573         reader = new StringReader(" ");
 574         source = new JsonSource(reader);
 575         source.skipWhiteSpace();
 576         assertEquals(-1, source.read());
 577
 578         reader = new StringReader("");
 579         source = new JsonSource(reader);
 580         source.skipWhiteSpace();
 581         assertEquals(-1, source.read());
 582
 583         return;
 584     }
 585
 586     /**
 587      * Test of hasMore method, of class JsonSource.
 588      */
 589     @Test
 590     public void testHasMore() throws Exception{
 591         System.out.println("hasMore");
 592
 593         JsonSource source;
 594         Reader reader;
 595
 596         reader = new StringReader("abc");
 597         source = new JsonSource(reader);
 598         assertTrue(source.hasMore());
 599         assertEquals('a', source.read());
 600         assertTrue(source.hasMore());
 601         assertEquals('b', source.read());
 602         assertTrue(source.hasMore());
 603         assertEquals('c', source.read());
 604         assertFalse(source.hasMore());
 605         source.unread('X');
 606         assertTrue(source.hasMore());
 607         assertEquals('X', source.read());
 608         assertFalse(source.hasMore());
 609
 610         reader = new StringReader("");
 611         source = new JsonSource(reader);
 612         assertFalse(source.hasMore());
 613
 614         return;
 615     }
 616
 617 }