src/test/java/jp/sourceforge/jovsonz/JsonAppenderTest.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.StringReader;
  10 import java.util.EmptyStackException;
  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 JsonAppenderTest {
  23
  24     public JsonAppenderTest() {
  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 JsonAppender.
  45      */
  46     @Test
  47     public void testConstructor(){
  48         System.out.println("constructor");
  49
  50         JsonAppender appender;
  51
  52         try{
  53             appender = new JsonAppender(null);
  54             fail();
  55         }catch(NullPointerException e){
  56             //GOOD
  57         }
  58
  59         appender = new JsonAppender(new StringBuilder());
  60         assertFalse(appender.hasIOException());
  61         assertNull(appender.getIOException());
  62
  63         return;
  64     }
  65
  66     /**
  67      * Test of pushComposition method, of class JsonAppender.
  68      */
  69     @Test
  70     public void testPushPopComposition(){
  71         System.out.println("pushComposition");
  72
  73         JsonAppender appender = new JsonAppender(new StringBuilder());
  74
  75         try{
  76             appender.popComposition();
  77             fail();
  78         }catch(EmptyStackException e){
  79             //GOOD
  80         }
  81         assertEquals(0, appender.nestDepth());
  82         assertTrue(appender.isNestEmpty());
  83
  84         JsObject obj1 = new JsObject();
  85         JsObject obj2 = new JsObject();
  86         JsArray array1 = new JsArray();
  87         JsArray array2 = new JsArray();
  88
  89         appender.pushComposition(obj1);
  90         appender.pushComposition(array1);
  91         appender.pushComposition(obj2);
  92         appender.pushComposition(array2);
  93
  94         assertEquals(4, appender.nestDepth());
  95         assertFalse(appender.isNestEmpty());
  96
  97         assertEquals(array2, appender.popComposition());
  98         assertEquals(obj2, appender.popComposition());
  99         assertEquals(array1, appender.popComposition());
 100         assertEquals(obj1, appender.popComposition());
 101
 102         try{
 103             appender.popComposition();
 104             fail();
 105         }catch(EmptyStackException e){
 106             //GOOD
 107         }
 108         assertEquals(0, appender.nestDepth());
 109         assertTrue(appender.isNestEmpty());
 110
 111         return;
 112     }
 113
 114     /**
 115      * Test of hasChildDumped setChildDumped method, of class JsonAppender.
 116      */
 117     @Test
 118     public void testHasSetChildDumped(){
 119         System.out.println("hasChildDumped");
 120
 121         JsonAppender appender;
 122
 123         appender = new JsonAppender(new StringBuilder());
 124         assertFalse(appender.hasChildDumped());
 125         appender.setChildDumped();
 126         assertFalse(appender.hasChildDumped());
 127
 128         appender.pushComposition(new JsObject());
 129         assertFalse(appender.hasChildDumped());
 130         appender.setChildDumped();
 131         assertTrue(appender.hasChildDumped());
 132
 133         appender.pushComposition(new JsObject());
 134         assertFalse(appender.hasChildDumped());
 135
 136         appender.popComposition();
 137         assertTrue(appender.hasChildDumped());
 138
 139         return;
 140     }
 141
 142     /**
 143      * Test of isArrayContext method, of class JsonAppender.
 144      */
 145     @Test
 146     public void testIsArrayContext(){
 147         System.out.println("isArrayContext");
 148         return;
 149     }
 150
 151     /**
 152      * Test of getIOException method, of class JsonAppender.
 153      */
 154     @Test
 155     public void testGetIOException() throws Exception{
 156         System.out.println("getIOException");
 157
 158         Reader reader = new StringReader("[1,2,3,4,5]");
 159         JsComposition<?> root = Json.parseJson(reader);
 160
 161         Appendable app = new TroubleAppender(3);
 162         JsonAppender appender = new JsonAppender(app);
 163
 164         assertFalse(appender.hasIOException());
 165         assertNull(appender.getIOException());
 166
 167         try{
 168             appender.append("abcde");
 169             fail();
 170         }catch(JsVisitException e){
 171             assertTrue(appender.hasIOException());
 172             assertEquals(e.getCause(), appender.getIOException());
 173         }
 174
 175         return;
 176     }
 177
 178     /**
 179      * Test of putPairName method, of class JsonAppender.
 180      */
 181     @Test
 182     public void testPutPairName() throws Exception{
 183         System.out.println("putPairName");
 184
 185         Appendable app;
 186         JsonAppender appender;
 187
 188         app = new TroubleAppender(1);
 189         appender = new JsonAppender(app);
 190
 191         try{
 192             appender.putPairName("A");
 193         }catch(JsVisitException e){
 194             assertTrue(appender.hasIOException());
 195             assertEquals(e.getCause(), appender.getIOException());
 196         }
 197
 198         return;
 199     }
 200
 201     /**
 202      * Test of append method, of class JsonAppender.
 203      */
 204     @Test
 205     public void testAppend() throws Exception{
 206         System.out.println("append");
 207
 208         Appendable app;
 209         JsonAppender appender;
 210
 211         app = new TroubleAppender(3);
 212         appender = new JsonAppender(app);
 213         appender.append('0');
 214         appender.append('1');
 215         appender.append('2');
 216         try{
 217             appender.append('3');
 218         }catch(JsVisitException e){
 219             assertTrue(appender.hasIOException());
 220             assertEquals(e.getCause(), appender.getIOException());
 221         }
 222
 223         app = new TroubleAppender(3);
 224         appender = new JsonAppender(app);
 225         try{
 226             appender.append("1234");
 227         }catch(JsVisitException e){
 228             assertTrue(appender.hasIOException());
 229             assertEquals(e.getCause(), appender.getIOException());
 230         }
 231
 232         return;
 233     }
 234
 235     /**
 236      * Test of flush method, of class JsonAppender.
 237      */
 238     @Test
 239     public void testFlush() throws Exception{
 240         System.out.println("flush");
 241
 242         Appendable app = new TroubleAppender(3);
 243         JsonAppender appender = new JsonAppender(app);
 244
 245         try{
 246             appender.flush();
 247             fail();
 248         }catch(JsVisitException e){
 249             assertTrue(appender.hasIOException());
 250             assertEquals(e.getCause(), appender.getIOException());
 251         }
 252
 253         return;
 254     }
 255
 256     /**
 257      * Test of hasIOException method, of class JsonAppender.
 258      */
 259     @Test
 260     public void testHasIOException(){
 261         System.out.println("hasIOException");
 262         return;
 263     }
 264
 265 }