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