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

   1 /*
   2  * License : The MIT License
   3  * Copyright(c) 2009 olyutorskii
   4  */
   5
   6 package jp.sourceforge.jovsonz;
   7
   8 import java.io.Reader;
   9 import java.io.IOException;
  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 JsonTest {
  23
  24     public JsonTest() {
  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 dumpJson method, of class Json.
  45      */
  46     @Test
  47     public void testDumpJson() throws Exception{
  48         System.out.println("dumpJson");
  49
  50         String SP2 = "\u0020\u0020";
  51         String SP4 = SP2 + SP2;
  52         String HASHSEP = "\u0020:\u0020";
  53
  54         Reader reader;
  55         JsComposition root;
  56         StringBuilder dump = new StringBuilder();
  57
  58         reader = new StringReader("{}");
  59         root = Json.parseJson(reader);
  60         dump.setLength(0);
  61         Json.dumpJson(dump, root);
  62         assertEquals("{ }\n", dump.toString());
  63
  64         reader = new StringReader("[]");
  65         root = Json.parseJson(reader);
  66         dump.setLength(0);
  67         Json.dumpJson(dump, root);
  68         assertEquals("[ ]\n", dump.toString());
  69
  70         reader = new StringReader("[1]");
  71         root = Json.parseJson(reader);
  72         dump.setLength(0);
  73         Json.dumpJson(dump, root);
  74         assertEquals("[\n"
  75                 + SP2+"1\n"
  76                 + "]\n", dump.toString());
  77
  78         reader = new StringReader("[1,2]");
  79         root = Json.parseJson(reader);
  80         dump.setLength(0);
  81         Json.dumpJson(dump, root);
  82         assertEquals("[\n"
  83                 + SP2+"1 ,\n"
  84                 + SP2+"2\n"
  85                 + "]\n", dump.toString());
  86
  87         reader = new StringReader("[1,[2],3]");
  88         root = Json.parseJson(reader);
  89         dump.setLength(0);
  90         Json.dumpJson(dump, root);
  91         assertEquals("[\n"
  92                 + SP2+"1 ,\n"
  93                 + SP2+"[\n"
  94                 + SP4+"2\n"
  95                 + SP2+"] ,\n"
  96                 + SP2+"3\n"
  97                 + "]\n", dump.toString());
  98
  99         reader = new StringReader("[1,{\"A\":\"a\"}]");
 100         root = Json.parseJson(reader);
 101         dump.setLength(0);
 102         Json.dumpJson(dump, root);
 103         assertEquals("[\n"
 104                 + SP2+"1 ,\n"
 105                 + SP2+"{\n"
 106                 + SP4+"\"A\""+HASHSEP+"\"a\"\n"
 107                 + SP2+"}\n"
 108                 + "]\n", dump.toString());
 109
 110         reader = new StringReader("{\"A\":\"a\"}");
 111         root = Json.parseJson(reader);
 112         dump.setLength(0);
 113         Json.dumpJson(dump, root);
 114         assertEquals("{\n"
 115                 + SP2+"\"A\""+HASHSEP+"\"a\"\n"
 116                 + "}\n", dump.toString());
 117
 118         reader = new StringReader("{\"A\":\"a\",\"B\":\"b\"}");
 119         root = Json.parseJson(reader);
 120         dump.setLength(0);
 121         Json.dumpJson(dump, root);
 122         assertEquals("{\n"
 123                 + SP2+"\"A\""+HASHSEP+"\"a\" ,\n"
 124                 + SP2+"\"B\""+HASHSEP+"\"b\"\n"
 125                 + "}\n", dump.toString());
 126
 127         reader = new StringReader("{\"A\":{}}");
 128         root = Json.parseJson(reader);
 129         dump.setLength(0);
 130         Json.dumpJson(dump, root);
 131         assertEquals("{\n"
 132                 + SP2+"\"A\""+HASHSEP+"{\u0020}\n"
 133                 + "}\n", dump.toString());
 134
 135         reader = new StringReader("{\"A\":{\"B\":\"b\"}}");
 136         root = Json.parseJson(reader);
 137         dump.setLength(0);
 138         Json.dumpJson(dump, root);
 139         assertEquals("{\n"
 140                 + SP2+"\"A\""+HASHSEP+"{\n"
 141                 + SP4+"\"B\""+HASHSEP+"\"b\"\n"
 142                 + SP2+"}\n"
 143                 + "}\n", dump.toString());
 144
 145         reader = new StringReader("{\"A\":[]}");
 146         root = Json.parseJson(reader);
 147         dump.setLength(0);
 148         Json.dumpJson(dump, root);
 149         assertEquals("{\n"
 150                 + SP2+"\"A\""+HASHSEP+"[\u0020]\n"
 151                 + "}\n", dump.toString());
 152
 153         reader = new StringReader("{\"A\":[1,2]}");
 154         root = Json.parseJson(reader);
 155         dump.setLength(0);
 156         Json.dumpJson(dump, root);
 157         assertEquals("{\n"
 158                 + SP2+"\"A\""+HASHSEP+"[\n"
 159                 + SP4+"1 ,\n"
 160                 + SP4+"2\n"
 161                 + SP2+"]\n"
 162                 + "}\n", dump.toString());
 163
 164         reader = new StringReader("["
 165                 + "true,false,null,\"string\",-0.5"
 166                 + "]");
 167         root = Json.parseJson(reader);
 168         dump.setLength(0);
 169         Json.dumpJson(dump, root);
 170         assertEquals("[\n"
 171                 + SP2+"true ,\n"
 172                 + SP2+"false ,\n"
 173                 + SP2+"null ,\n"
 174                 + SP2+"\"string\" ,\n"
 175                 + SP2+"-0.5\n"
 176                 + "]\n", dump.toString());
 177
 178         try{
 179             Json.dumpJson(null, new JsObject());
 180             fail();
 181         }catch(NullPointerException e){
 182             //GOOD
 183         }
 184
 185         try{
 186             Json.dumpJson(new StringBuilder(), null);
 187             fail();
 188         }catch(NullPointerException e){
 189             //GOOD
 190         }
 191
 192         reader = new StringReader("[1,2,3]");
 193         root = Json.parseJson(reader);
 194         TroubleAppender app = new TroubleAppender(3);
 195         try{
 196             Json.dumpJson(app, root);
 197             fail();
 198         }catch(IOException e){
 199             //GOOD
 200         }
 201
 202         return;
 203     }
 204
 205     /**
 206      * Test of parseValue method, of class Json.
 207      */
 208     @Test
 209     public void testParseValue() throws Exception{
 210         System.out.println("parseValue");
 211
 212         JsonSource source;
 213         JsValue value;
 214
 215         source = new JsonSource("true");
 216         value = Json.parseValue(source);
 217         assertEquals(JsBoolean.TRUE, value);
 218
 219         source = new JsonSource("false");
 220         value = Json.parseValue(source);
 221         assertEquals(JsBoolean.FALSE, value);
 222
 223         source = new JsonSource("null");
 224         value = Json.parseValue(source);
 225         assertEquals(JsNull.NULL, value);
 226
 227         source = new JsonSource("-0.5");
 228         value = Json.parseValue(source);
 229         assertEquals(JsTypes.NUMBER, value.getJsTypes());
 230         assertEquals(-0.5, ((JsNumber)value).doubleValue(), 0.0);
 231
 232         source = new JsonSource("\"ABC\"");
 233         value = Json.parseValue(source);
 234         assertEquals(JsTypes.STRING, value.getJsTypes());
 235         assertEquals("ABC", ((JsString)value).toRawString());
 236
 237         source = new JsonSource("[1,2,3]");
 238         value = Json.parseValue(source);
 239         assertEquals(JsTypes.ARRAY, value.getJsTypes());
 240         assertEquals(3, ((JsArray)value).size());
 241
 242         source = new JsonSource("{\"A\":1,\"B\":2,\"C\":3}");
 243         value = Json.parseValue(source);
 244         assertEquals(JsTypes.OBJECT, value.getJsTypes());
 245         assertEquals(3, ((JsObject)value).size());
 246
 247         source = new JsonSource("");
 248         value = Json.parseValue(source);
 249         assertNull(value);
 250
 251         source = new JsonSource(" ");
 252         value = Json.parseValue(source);
 253         assertNull(value);
 254
 255         try{
 256             source = new JsonSource("#");
 257             value = Json.parseValue(source);
 258             fail();
 259         }catch(JsParseException e){
 260             //GOOD
 261         }
 262
 263         return;
 264     }
 265
 266     /**
 267      * Test of parseJson method, of class Json.
 268      */
 269     @Test
 270     public void testParseJson() throws Exception{
 271         System.out.println("parseJson");
 272
 273         Reader reader;
 274         JsComposition root;
 275
 276         reader = new StringReader("{}");
 277         root = Json.parseJson(reader);
 278         assertNotNull(root);
 279         assertEquals(JsTypes.OBJECT, root.getJsTypes());
 280         assertEquals(0, root.size());
 281
 282         reader = new StringReader("{\"name\":\"value\"}");
 283         root = Json.parseJson(reader);
 284         assertNotNull(root);
 285         assertEquals(JsTypes.OBJECT, root.getJsTypes());
 286         assertEquals(1, root.size());
 287
 288         reader = new StringReader(" { \"name\" : \"value\" } ");
 289         root = Json.parseJson(reader);
 290         assertNotNull(root);
 291         assertEquals(JsTypes.OBJECT, root.getJsTypes());
 292         assertEquals(1, root.size());
 293
 294         reader = new StringReader("[]");
 295         root = Json.parseJson(reader);
 296         assertNotNull(root);
 297         assertEquals(JsTypes.ARRAY, root.getJsTypes());
 298         assertEquals(0, root.size());
 299
 300         reader = new StringReader("[1,2,3]");
 301         root = Json.parseJson(reader);
 302         assertNotNull(root);
 303         assertEquals(JsTypes.ARRAY, root.getJsTypes());
 304         assertEquals(3, root.size());
 305
 306         reader = new StringReader(" [ 1 , 2 , 3 ] ");
 307         root = Json.parseJson(reader);
 308         assertNotNull(root);
 309         assertEquals(JsTypes.ARRAY, root.getJsTypes());
 310         assertEquals(3, root.size());
 311
 312         reader = new StringReader("");
 313         root = Json.parseJson(reader);
 314         assertNull(root);
 315
 316         reader = new StringReader(" ");
 317         root = Json.parseJson(reader);
 318         assertNull(root);
 319
 320         try{
 321             reader = new StringReader("true");
 322             root = Json.parseJson(reader);
 323             fail();
 324         }catch(JsParseException e){
 325             //GOOD
 326         }
 327
 328         try{
 329             reader = new StringReader("false");
 330             root = Json.parseJson(reader);
 331             fail();
 332         }catch(JsParseException e){
 333             //GOOD
 334         }
 335
 336         try{
 337             reader = new StringReader("null");
 338             root = Json.parseJson(reader);
 339             fail();
 340         }catch(JsParseException e){
 341             //GOOD
 342         }
 343
 344         try{
 345             reader = new StringReader("\"ABC\"");
 346             root = Json.parseJson(reader);
 347             fail();
 348         }catch(JsParseException e){
 349             //GOOD
 350         }
 351
 352         try{
 353             reader = new StringReader("-0.5");
 354             root = Json.parseJson(reader);
 355             fail();
 356         }catch(JsParseException e){
 357             //GOOD
 358         }
 359
 360         try{
 361             reader = new StringReader("#");
 362             root = Json.parseJson(reader);
 363             fail();
 364         }catch(JsParseException e){
 365             //GOOD
 366         }
 367
 368         try{
 369             reader = new StringReader(" [ 1 , 2 , 3 ");
 370             root = Json.parseJson(reader);
 371             fail();
 372         }catch(JsParseException e){
 373             //GOOD
 374         }
 375
 376         try{
 377             reader = new TroubleReader(" [ 1 , 2 , 3 ] ", 3);
 378             root = Json.parseJson(reader);
 379             fail();
 380         }catch(IOException e){
 381             //GOOD
 382         }
 383
 384         return;
 385     }
 386
 387 }