src/test/java/jp/sourceforge/jindolf/json/JsStringTest.java

   1 /*
   2  * Copyright(c) 2009 olyutorskii
   3  */
   4
   5 package jp.sourceforge.jindolf.json;
   6
   7 import java.io.StringReader;
   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 import static org.junit.Assert.*;
  16
  17 /**
  18  *
  19  */
  20 public class JsStringTest {
  21
  22     public JsStringTest() {
  23     }
  24
  25     @BeforeClass
  26     public static void setUpClass() throws Exception{
  27     }
  28
  29     @AfterClass
  30     public static void tearDownClass() throws Exception{
  31     }
  32
  33     @Before
  34     public void setUp() {
  35     }
  36
  37     @After
  38     public void tearDown() {
  39     }
  40
  41     /**
  42      * Test of parseHexChar method, of class JsString.
  43      */
  44     @Test
  45     public void testParseHexChar() throws Exception{
  46         System.out.println("parseHexChar");
  47
  48         JsonReader reader;
  49         char ch;
  50
  51         reader = new JsonReader(new StringReader("0000"));
  52         ch = JsString.parseHexChar(reader);
  53         assertEquals('\u0000', ch);
  54
  55         reader = new JsonReader(new StringReader("ffff"));
  56         ch = JsString.parseHexChar(reader);
  57         assertEquals('\uffff', ch);
  58
  59         reader = new JsonReader(new StringReader("FFFF"));
  60         ch = JsString.parseHexChar(reader);
  61         assertEquals('\uffff', ch);
  62
  63         reader = new JsonReader(new StringReader("dead"));
  64         ch = JsString.parseHexChar(reader);
  65         assertEquals('\udead', ch);
  66
  67         reader = new JsonReader(new StringReader("abcde"));
  68         ch = JsString.parseHexChar(reader);
  69         assertEquals('\uabcd', ch);
  70
  71         try{
  72             reader = new JsonReader(new StringReader("000,"));
  73             ch = JsString.parseHexChar(reader);
  74             fail();
  75         }catch(JsParseException e){
  76             // NOTHING
  77         }
  78
  79         return;
  80     }
  81
  82     /**
  83      * Test of parseString method, of class JsString.
  84      */
  85     @Test
  86     public void testParseString() throws Exception{
  87         System.out.println("parseString");
  88
  89         JsonReader reader;
  90         JsString string;
  91
  92         reader = new JsonReader(new StringReader("\"abc\""));
  93         string = JsString.parseString(reader);
  94         assertEquals("abc", string.toRawString());
  95
  96         reader = new JsonReader(new StringReader("\"あいう\""));
  97         string = JsString.parseString(reader);
  98         assertEquals("あいう", string.toRawString());
  99
 100         reader = new JsonReader(new StringReader("\"\\\"\\\\\\/\""));
 101         string = JsString.parseString(reader);
 102         assertEquals("\"\\/", string.toRawString());
 103
 104         reader = new JsonReader(new StringReader("\"\\b\\f\\n\\r\\t\""));
 105         string = JsString.parseString(reader);
 106         assertEquals("\b\f\n\r\t", string.toRawString());
 107
 108         reader = new JsonReader(new StringReader("\"\\uabcd\\uCDEF\""));
 109         string = JsString.parseString(reader);
 110         assertEquals("\uabcd\ucdef", string.toRawString());
 111
 112         try{
 113             reader = new JsonReader(new StringReader("abc\""));
 114             string = JsString.parseString(reader);
 115             fail();
 116         }catch(JsParseException e){
 117             // NOTHING
 118         }
 119
 120         try{
 121             reader = new JsonReader(new StringReader("\"abc"));
 122             string = JsString.parseString(reader);
 123             fail();
 124         }catch(JsParseException e){
 125             // NOTHING
 126         }
 127
 128         return;
 129     }
 130
 131     /**
 132      * Test of writeText method, of class JsString.
 133      */
 134     @Test
 135     public void testWriteText() throws Exception{
 136         System.out.println("writeText");
 137
 138         Appendable appout;
 139         JsString string;
 140
 141         appout = new StringBuilder();
 142         string = new JsString();
 143         JsString.writeText(appout, string);
 144         assertEquals("\"\"", appout.toString());
 145
 146         appout = new StringBuilder();
 147         string = new JsString("abc");
 148         JsString.writeText(appout, string);
 149         assertEquals("\"abc\"", appout.toString());
 150
 151         appout = new StringBuilder();
 152         string = new JsString("\"");
 153         JsString.writeText(appout, string);
 154         assertEquals("\"\\\"\"", appout.toString());
 155
 156         appout = new StringBuilder();
 157         string = new JsString("\\");
 158         JsString.writeText(appout, string);
 159         assertEquals("\"\\\\\"", appout.toString());
 160
 161         appout = new StringBuilder();
 162         string = new JsString("/");
 163         JsString.writeText(appout, string);
 164         assertEquals("\"\\/\"", appout.toString());
 165
 166         appout = new StringBuilder();
 167         string = new JsString("\b");
 168         JsString.writeText(appout, string);
 169         assertEquals("\"\\b\"", appout.toString());
 170
 171         appout = new StringBuilder();
 172         string = new JsString("\f");
 173         JsString.writeText(appout, string);
 174         assertEquals("\"\\f\"", appout.toString());
 175
 176         appout = new StringBuilder();
 177         string = new JsString("\n");
 178         JsString.writeText(appout, string);
 179         assertEquals("\"\\n\"", appout.toString());
 180
 181         appout = new StringBuilder();
 182         string = new JsString("\r");
 183         JsString.writeText(appout, string);
 184         assertEquals("\"\\r\"", appout.toString());
 185
 186         appout = new StringBuilder();
 187         string = new JsString("\t");
 188         JsString.writeText(appout, string);
 189         assertEquals("\"\\t\"", appout.toString());
 190
 191         appout = new StringBuilder();
 192         string = new JsString("\u0001");
 193         JsString.writeText(appout, string);
 194         assertEquals("\"\\u0001\"", appout.toString());
 195
 196         appout = new StringBuilder();
 197         string = new JsString("あ");
 198         JsString.writeText(appout, string);
 199         assertEquals("\"あ\"", appout.toString());
 200
 201         return;
 202     }
 203
 204     /**
 205      * Test of traverse method, of class JsString.
 206      */
 207     @Test
 208     public void testTraverse(){
 209         System.out.println("traverse");
 210
 211         JsString string = new JsString("A");
 212
 213         try{
 214             string.traverse(new ValueVisitor(){
 215                 int ct = 0;
 216
 217                 public void visitValue(JsValue value)
 218                         throws JsVisitException{
 219                     assertEquals(new JsString("A"), value);
 220                     assertTrue(this.ct++ <= 0);
 221                 }
 222
 223                 public void visitPairName(String name)
 224                         throws JsVisitException{
 225                     throw new JsVisitException();
 226                 }
 227
 228                 public void visitCollectionClose(JsValue composite)
 229                         throws JsVisitException{
 230                     throw new JsVisitException();
 231                 }
 232             });
 233         }catch(JsVisitException e){
 234             fail();
 235         }
 236
 237         return;
 238     }
 239
 240     /**
 241      * Test of hasChanged method, of class JsString.
 242      */
 243     @Test
 244     public void testHasChanged(){
 245         System.out.println("hasChanged");
 246
 247         JsString string = new JsString("A");
 248
 249         assertFalse(string.hasChanged());
 250         string.setUnchanged();
 251         assertFalse(string.hasChanged());
 252
 253         return;
 254     }
 255
 256     /**
 257      * Test of setUnchanged method, of class JsString.
 258      */
 259     @Test
 260     public void testSetUnchanged(){
 261         System.out.println("setUnchanged");
 262
 263         JsString string = new JsString("A");
 264
 265         string.setUnchanged();
 266         assertFalse(string.hasChanged());
 267
 268         return;
 269     }
 270
 271     /**
 272      * Test of charAt method, of class JsString.
 273      */
 274     @Test
 275     public void testCharAt(){
 276         System.out.println("charAt");
 277
 278         JsString string;
 279
 280         string = new JsString("abcde");
 281         assertEquals('b', string.charAt(1));
 282
 283         try{
 284             string.charAt(999);
 285             fail();
 286         }catch(IndexOutOfBoundsException e){
 287             // NOTHING
 288         }
 289
 290         return;
 291     }
 292
 293     /**
 294      * Test of length method, of class JsString.
 295      */
 296     @Test
 297     public void testLength(){
 298         System.out.println("length");
 299
 300         assertEquals(0, new JsString().length());
 301         assertEquals(0, new JsString("").length());
 302         assertEquals(1, new JsString("A").length());
 303         assertEquals(2, new JsString("AB").length());
 304         assertEquals(3, new JsString("A\"B").length());
 305
 306         return;
 307     }
 308
 309     /**
 310      * Test of subSequence method, of class JsString.
 311      */
 312     @Test
 313     public void testSubSequence(){
 314         System.out.println("subSequence");
 315
 316         JsString string;
 317
 318         string = new JsString("abcde");
 319         assertEquals("bcd", string.subSequence(1, 4).toString());
 320         assertEquals("", string.subSequence(1, 1).toString());
 321
 322         try{
 323             string.subSequence(1,999);
 324             fail();
 325         }catch(IndexOutOfBoundsException e){
 326             // NOTHING
 327         }
 328
 329         return;
 330     }
 331
 332     /**
 333      * Test of hashCode method, of class JsString.
 334      */
 335     @Test
 336     public void testHashCode(){
 337         System.out.println("hashCode");
 338         assertEquals(new JsString("A").hashCode(), new JsString("A").hashCode());
 339         return;
 340     }
 341
 342     /**
 343      * Test of equals method, of class JsString.
 344      */
 345     @Test
 346     public void testEquals(){
 347         System.out.println("equals");
 348
 349         assertTrue(new JsString("A").equals(new JsString("A")));
 350         assertFalse(new JsString("A").equals(new JsString("a")));
 351         assertFalse(new JsString("A").equals(null));
 352
 353         return;
 354     }
 355
 356     /**
 357      * Test of compareTo method, of class JsString.
 358      */
 359     @Test
 360     public void testCompareTo(){
 361         System.out.println("compareTo");
 362
 363         assertTrue(0 == new JsString("A").compareTo(new JsString("A")));
 364         assertTrue(0 > new JsString("A").compareTo(new JsString("a")));
 365         assertTrue(0 < new JsString("a").compareTo(new JsString("A")));
 366         assertTrue(0 < new JsString("A").compareTo(null));
 367
 368         SortedSet<JsString> set = new TreeSet<JsString>();
 369
 370         set.clear();
 371         set.add(new JsString("A"));
 372         set.add(new JsString("a"));
 373         assertEquals(new JsString("A"), set.first());
 374         assertEquals(new JsString("a"), set.last());
 375
 376         set.clear();
 377         set.add(new JsString("a"));
 378         set.add(new JsString("A"));
 379         assertEquals(new JsString("A"), set.first());
 380         assertEquals(new JsString("a"), set.last());
 381
 382         return;
 383     }
 384
 385     /**
 386      * Test of toString method, of class JsString.
 387      */
 388     @Test
 389     public void testToString(){
 390         System.out.println("toString");
 391
 392         assertEquals("\"\"", new JsString("").toString());
 393         assertEquals("\"abc\"", new JsString("abc").toString());
 394         assertEquals("\"\\\"\"", new JsString("\"").toString());
 395         assertEquals("\"\\\\\"", new JsString("\\").toString());
 396         assertEquals("\"\\/\"", new JsString("/").toString());
 397         assertEquals("\"\\b\"", new JsString("\b").toString());
 398         assertEquals("\"\\f\"", new JsString("\f").toString());
 399         assertEquals("\"\\n\"", new JsString("\n").toString());
 400         assertEquals("\"\\r\"", new JsString("\r").toString());
 401         assertEquals("\"\\t\"", new JsString("\t").toString());
 402         assertEquals("\"\\u0001\"", new JsString("\u0001").toString());
 403         assertEquals("\"あ\"", new JsString("あ").toString());
 404
 405         return;
 406     }
 407
 408     /**
 409      * Test of toRawString method, of class JsString.
 410      */
 411     @Test
 412     public void testToRawString(){
 413         System.out.println("toRawString");
 414
 415         assertEquals("", new JsString("").toRawString());
 416         assertEquals("abc", new JsString("abc").toRawString());
 417         assertEquals("\"", new JsString("\"").toRawString());
 418         assertEquals("\\", new JsString("\\").toRawString());
 419         assertEquals("/", new JsString("/").toRawString());
 420         assertEquals("\b", new JsString("\b").toRawString());
 421         assertEquals("\f", new JsString("\f").toRawString());
 422         assertEquals("\n", new JsString("\n").toRawString());
 423         assertEquals("\r", new JsString("\r").toRawString());
 424         assertEquals("\t", new JsString("\t").toRawString());
 425         assertEquals("\u0001", new JsString("\u0001").toRawString());
 426         assertEquals("あ", new JsString("あ").toRawString());
 427
 428         return;
 429     }
 430
 431 }