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

   1 /*
   2  * License : The MIT License
   3  * Copyright(c) 2009 olyutorskii
   4  */
   5
   6 package jp.sourceforge.jovsonz;
   7
   8 import java.util.SortedSet;
   9 import java.util.TreeSet;
  10 import org.junit.After;
  11 import org.junit.AfterClass;
  12 import org.junit.Before;
  13 import org.junit.BeforeClass;
  14 import org.junit.Test;
  15
  16 import static org.junit.Assert.*;
  17
  18 /**
  19  *
  20  */
  21 public class JsStringTest {
  22
  23     public JsStringTest() {
  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 JsString.
  44      */
  45     @Test
  46     public void testConstructor() throws Exception{
  47         System.out.println("constructor");
  48
  49         JsString string;
  50
  51         string = new JsString();
  52         assertEquals("", string.toRawString());
  53
  54         string = new JsString("");
  55         assertEquals("", string.toRawString());
  56
  57         string = new JsString("x");
  58         assertEquals("x", string.toRawString());
  59
  60         string = new JsString("\u001f");
  61         assertEquals("\u001f", string.toRawString());
  62         assertEquals("\"\\u001f\"", string.toString());
  63
  64         try{
  65             string = new JsString(null);
  66             fail();
  67         }catch(NullPointerException e){
  68             //NOTHING
  69         }
  70
  71         return;
  72     }
  73
  74     /**
  75      * Test of parseHexChar method, of class JsString.
  76      */
  77     @Test
  78     public void testParseHexChar() throws Exception{
  79         System.out.println("parseHexChar");
  80
  81         JsonSource source;
  82         char ch;
  83
  84         source = new JsonSource("0000");
  85         ch = JsString.parseHexChar(source);
  86         assertEquals('\u0000', ch);
  87
  88         source = new JsonSource("ffff");
  89         ch = JsString.parseHexChar(source);
  90         assertEquals('\uffff', ch);
  91
  92         source = new JsonSource("FFFF");
  93         ch = JsString.parseHexChar(source);
  94         assertEquals('\uffff', ch);
  95
  96         source = new JsonSource("dead");
  97         ch = JsString.parseHexChar(source);
  98         assertEquals('\udead', ch);
  99
 100         source = new JsonSource("abcde");
 101         ch = JsString.parseHexChar(source);
 102         assertEquals('\uabcd', ch);
 103
 104         try{
 105             source = new JsonSource("000,");
 106             ch = JsString.parseHexChar(source);
 107             fail();
 108         }catch(JsParseException e){
 109             // NOTHING
 110         }
 111
 112         return;
 113     }
 114
 115     /**
 116      * Test of parseString method, of class JsString.
 117      */
 118     @Test
 119     public void testParseString() throws Exception{
 120         System.out.println("parseString");
 121
 122         JsonSource source;
 123         JsString string;
 124
 125         source = new JsonSource("\"abc\"");
 126         string = JsString.parseString(source);
 127         assertEquals("abc", string.toRawString());
 128
 129         source = new JsonSource("\"あいう\"");
 130         string = JsString.parseString(source);
 131         assertEquals("あいう", string.toRawString());
 132
 133         source = new JsonSource("\"\\\"\\\\\\/\"");
 134         string = JsString.parseString(source);
 135         assertEquals("\"\\/", string.toRawString());
 136
 137         source = new JsonSource("\"\\b\\f\\n\\r\\t\"");
 138         string = JsString.parseString(source);
 139         assertEquals("\b\f\n\r\t", string.toRawString());
 140
 141         source = new JsonSource("\"\\uabcd\\uCDEF\"");
 142         string = JsString.parseString(source);
 143         assertEquals("\uabcd\ucdef", string.toRawString());
 144
 145         source = new JsonSource("abc\"");
 146         string = JsString.parseString(source);
 147         assertNull(string);
 148
 149         try{
 150             source = new JsonSource("\"abc");
 151             string = JsString.parseString(source);
 152             fail();
 153         }catch(JsParseException e){
 154             // NOTHING
 155         }
 156
 157         try{
 158             source = new JsonSource("\"\\#\"");
 159             string = JsString.parseString(source);
 160             fail();
 161         }catch(JsParseException e){
 162             // NOTHING
 163         }
 164
 165         try{
 166             source = new JsonSource("\"\\u#999\"");
 167             string = JsString.parseString(source);
 168             fail();
 169         }catch(JsParseException e){
 170             // NOTHING
 171         }
 172
 173         try{
 174             source = new JsonSource("\"\\u9#99\"");
 175             string = JsString.parseString(source);
 176             fail();
 177         }catch(JsParseException e){
 178             // NOTHING
 179         }
 180
 181         try{
 182             source = new JsonSource("\"\\u99#9\"");
 183             string = JsString.parseString(source);
 184             fail();
 185         }catch(JsParseException e){
 186             // NOTHING
 187         }
 188
 189         try{
 190             source = new JsonSource("\"\\u999#\"");
 191             string = JsString.parseString(source);
 192             fail();
 193         }catch(JsParseException e){
 194             // NOTHING
 195         }
 196
 197         try{
 198             source = new JsonSource("\"abc\nxyz\"");
 199             string = JsString.parseString(source);
 200             fail();
 201         }catch(JsParseException e){
 202             // NOTHING
 203         }
 204
 205         return;
 206     }
 207
 208     /**
 209      * Test of dumpString method, of class JsString.
 210      */
 211     @Test
 212     public void testDumpString() throws Exception{
 213         System.out.println("writeText");
 214
 215         Appendable appout;
 216         JsString string;
 217
 218         appout = new StringBuilder();
 219         string = new JsString();
 220         JsString.dumpString(appout, string);
 221         assertEquals("\"\"", appout.toString());
 222
 223         appout = new StringBuilder();
 224         string = new JsString("abc");
 225         JsString.dumpString(appout, string);
 226         assertEquals("\"abc\"", appout.toString());
 227
 228         appout = new StringBuilder();
 229         string = new JsString("\"");
 230         JsString.dumpString(appout, string);
 231         assertEquals("\"\\\"\"", appout.toString());
 232
 233         appout = new StringBuilder();
 234         string = new JsString("\\");
 235         JsString.dumpString(appout, string);
 236         assertEquals("\"\\\\\"", appout.toString());
 237
 238         appout = new StringBuilder();
 239         string = new JsString("/");
 240         JsString.dumpString(appout, string);
 241         assertEquals("\"\\/\"", appout.toString());
 242
 243         appout = new StringBuilder();
 244         string = new JsString("\b");
 245         JsString.dumpString(appout, string);
 246         assertEquals("\"\\b\"", appout.toString());
 247
 248         appout = new StringBuilder();
 249         string = new JsString("\f");
 250         JsString.dumpString(appout, string);
 251         assertEquals("\"\\f\"", appout.toString());
 252
 253         appout = new StringBuilder();
 254         string = new JsString("\n");
 255         JsString.dumpString(appout, string);
 256         assertEquals("\"\\n\"", appout.toString());
 257
 258         appout = new StringBuilder();
 259         string = new JsString("\r");
 260         JsString.dumpString(appout, string);
 261         assertEquals("\"\\r\"", appout.toString());
 262
 263         appout = new StringBuilder();
 264         string = new JsString("\t");
 265         JsString.dumpString(appout, string);
 266         assertEquals("\"\\t\"", appout.toString());
 267
 268         appout = new StringBuilder();
 269         string = new JsString("\u0001");
 270         JsString.dumpString(appout, string);
 271         assertEquals("\"\\u0001\"", appout.toString());
 272
 273         appout = new StringBuilder();
 274         string = new JsString("あ");
 275         JsString.dumpString(appout, string);
 276         assertEquals("\"あ\"", appout.toString());
 277
 278         return;
 279     }
 280
 281     /**
 282      * Test of escapeText method, of class JsString.
 283      */
 284     @Test
 285     public void testEscapeText(){
 286         System.out.println("escapeText");
 287
 288         assertEquals("\"A\"", JsString.escapeText("A").toString());
 289
 290         return;
 291     }
 292
 293     /**
 294      * Test of traverse method, of class JsString.
 295      */
 296     @Test
 297     public void testTraverse(){
 298         System.out.println("traverse");
 299
 300         JsString string = new JsString("A");
 301
 302         try{
 303             string.traverse(new ValueVisitor(){
 304                 int ct = 0;
 305
 306                 public void visitValue(JsValue value)
 307                         throws JsVisitException{
 308                     assertEquals(new JsString("A"), value);
 309                     assertTrue(this.ct++ <= 0);
 310                 }
 311
 312                 public void visitPairName(String name)
 313                         throws JsVisitException{
 314                     throw new JsVisitException();
 315                 }
 316
 317                 public void visitCompositionClose(JsComposition composite)
 318                         throws JsVisitException{
 319                     throw new JsVisitException();
 320                 }
 321             });
 322         }catch(JsVisitException e){
 323             fail();
 324         }
 325
 326         return;
 327     }
 328
 329     /**
 330      * Test of charAt method, of class JsString.
 331      */
 332     @Test
 333     public void testCharAt(){
 334         System.out.println("charAt");
 335
 336         JsString string;
 337
 338         string = new JsString("abcde");
 339         assertEquals('b', string.charAt(1));
 340
 341         try{
 342             string.charAt(999);
 343             fail();
 344         }catch(IndexOutOfBoundsException e){
 345             // NOTHING
 346         }
 347
 348         return;
 349     }
 350
 351     /**
 352      * Test of length method, of class JsString.
 353      */
 354     @Test
 355     public void testLength(){
 356         System.out.println("length");
 357
 358         assertEquals(0, new JsString().length());
 359         assertEquals(0, new JsString("").length());
 360         assertEquals(1, new JsString("A").length());
 361         assertEquals(2, new JsString("AB").length());
 362         assertEquals(3, new JsString("A\"B").length());
 363
 364         return;
 365     }
 366
 367     /**
 368      * Test of subSequence method, of class JsString.
 369      */
 370     @Test
 371     public void testSubSequence(){
 372         System.out.println("subSequence");
 373
 374         JsString string;
 375
 376         string = new JsString("abcde");
 377         assertEquals("bcd", string.subSequence(1, 4).toString());
 378         assertEquals("", string.subSequence(1, 1).toString());
 379
 380         try{
 381             string.subSequence(1,999);
 382             fail();
 383         }catch(IndexOutOfBoundsException e){
 384             // NOTHING
 385         }
 386
 387         return;
 388     }
 389
 390     /**
 391      * Test of hashCode method, of class JsString.
 392      */
 393     @Test
 394     public void testHashCode(){
 395         System.out.println("hashCode");
 396         assertEquals(new JsString("A").hashCode(), new JsString("A").hashCode());
 397         return;
 398     }
 399
 400     /**
 401      * Test of equals method, of class JsString.
 402      */
 403     @Test
 404     public void testEquals(){
 405         System.out.println("equals");
 406
 407         assertTrue(new JsString("A").equals(new JsString("A")));
 408         assertFalse(new JsString("A").equals(new JsString("a")));
 409         JsString nullVal = null;
 410         assertFalse(new JsString("A").equals(nullVal));
 411
 412         assertFalse(new JsString("A").equals(""));
 413
 414         return;
 415     }
 416
 417     /**
 418      * Test of compareTo method, of class JsString.
 419      */
 420     @Test
 421     public void testCompareTo(){
 422         System.out.println("compareTo");
 423
 424         assertTrue(0 == new JsString("A").compareTo(new JsString("A")));
 425         assertTrue(0 > new JsString("A").compareTo(new JsString("a")));
 426         assertTrue(0 < new JsString("a").compareTo(new JsString("A")));
 427         assertTrue(0 < new JsString("A").compareTo(null));
 428
 429         SortedSet<JsString> set = new TreeSet<JsString>();
 430
 431         set.clear();
 432         set.add(new JsString("A"));
 433         set.add(new JsString("a"));
 434         assertEquals(new JsString("A"), set.first());
 435         assertEquals(new JsString("a"), set.last());
 436
 437         set.clear();
 438         set.add(new JsString("a"));
 439         set.add(new JsString("A"));
 440         assertEquals(new JsString("A"), set.first());
 441         assertEquals(new JsString("a"), set.last());
 442
 443         JsString string = new JsString("A");
 444         assertEquals(0, string.compareTo(string));
 445
 446         return;
 447     }
 448
 449     /**
 450      * Test of toString method, of class JsString.
 451      */
 452     @Test
 453     public void testToString(){
 454         System.out.println("toString");
 455
 456         assertEquals("\"\"", new JsString("").toString());
 457         assertEquals("\"abc\"", new JsString("abc").toString());
 458         assertEquals("\"\\\"\"", new JsString("\"").toString());
 459         assertEquals("\"\\\\\"", new JsString("\\").toString());
 460         assertEquals("\"\\/\"", new JsString("/").toString());
 461         assertEquals("\"\\b\"", new JsString("\b").toString());
 462         assertEquals("\"\\f\"", new JsString("\f").toString());
 463         assertEquals("\"\\n\"", new JsString("\n").toString());
 464         assertEquals("\"\\r\"", new JsString("\r").toString());
 465         assertEquals("\"\\t\"", new JsString("\t").toString());
 466         assertEquals("\"\\u0001\"", new JsString("\u0001").toString());
 467         assertEquals("\"あ\"", new JsString("あ").toString());
 468
 469         return;
 470     }
 471
 472     /**
 473      * Test of toRawString method, of class JsString.
 474      */
 475     @Test
 476     public void testToRawString(){
 477         System.out.println("toRawString");
 478
 479         assertEquals("", new JsString("").toRawString());
 480         assertEquals("abc", new JsString("abc").toRawString());
 481         assertEquals("\"", new JsString("\"").toRawString());
 482         assertEquals("\\", new JsString("\\").toRawString());
 483         assertEquals("/", new JsString("/").toRawString());
 484         assertEquals("\b", new JsString("\b").toRawString());
 485         assertEquals("\f", new JsString("\f").toRawString());
 486         assertEquals("\n", new JsString("\n").toRawString());
 487         assertEquals("\r", new JsString("\r").toRawString());
 488         assertEquals("\t", new JsString("\t").toRawString());
 489         assertEquals("\u0001", new JsString("\u0001").toRawString());
 490         assertEquals("あ", new JsString("あ").toRawString());
 491
 492         return;
 493     }
 494
 495     /**
 496      * Test of getJsTypes method, of class JsString.
 497      */
 498     @Test
 499     public void testGetJsTypes() {
 500         System.out.println("getJsTypes");
 501
 502         JsString instance = new JsString();
 503
 504         assertEquals(JsTypes.STRING, instance.getJsTypes());
 505
 506         return;
 507     }
 508
 509 }