src/test/java/jp/osdn/jindolf/parser/content/SjisNotifierTest.java

   1 /*
   2  */
   3
   4 package jp.osdn.jindolf.parser.content;
   5
   6 import io.bitbucket.olyutorskii.jiocema.DecodeNotifier;
   7 import java.io.InputStream;
   8 import org.junit.After;
   9 import org.junit.AfterClass;
  10 import org.junit.Before;
  11 import org.junit.BeforeClass;
  12 import org.junit.Test;
  13
  14 import static org.junit.Assert.*;
  15
  16 /**
  17  *
  18  */
  19 public class SjisNotifierTest {
  20
  21
  22
  23     public SjisNotifierTest() {
  24     }
  25
  26     @BeforeClass
  27     public static void setUpClass() {
  28     }
  29
  30     @AfterClass
  31     public static void tearDownClass() {
  32     }
  33
  34     @Before
  35     public void setUp() {
  36     }
  37
  38     @After
  39     public void tearDown() {
  40     }
  41
  42     @Test
  43     public void testConstructor() throws Exception{
  44         DecodeNotifier decoder;
  45
  46         decoder = new SjisNotifier();
  47         assert decoder == decoder;
  48
  49         decoder = new SjisNotifier(2, 2);
  50         assert decoder == decoder;
  51
  52         try{
  53             decoder = new SjisNotifier(1, 2);
  54             fail();
  55         }catch(IllegalArgumentException e){
  56             assertEquals("input buffer length must be 2 or more for Shift_JIS", e.getMessage());
  57         }
  58
  59         try{
  60             decoder = new SjisNotifier(2, 1);
  61             fail();
  62         }catch(IllegalArgumentException e){
  63             assertEquals("output buffer length must be 2 or more for surrogate pair", e.getMessage());
  64         }
  65
  66         assert decoder == decoder;
  67
  68         return;
  69     }
  70
  71     @Test
  72     public void testJisX0201() throws Exception{
  73         DecodeNotifier decoder;
  74         TestListener lst;
  75         InputStream is;
  76
  77         decoder = new SjisNotifier();
  78
  79         lst = new TestListenerRW();
  80         decoder.setCharDecodeListener(lst);
  81
  82         // test JISX0201 ASCII decoding
  83
  84         lst.clear();
  85         is = Bseq.byteStream(0x00, 0x1f, 0x20, 0x21, 0x7f);
  86         decoder.decode(is);
  87         assertEquals("[ST][RW]001f20217f[CH]\u0000\u001f\u0020\u0021\u007f[EN]", lst.toString());
  88
  89         // test JISX0201 Hankaku-Katakana decoding
  90
  91         lst.clear();
  92         is = Bseq.byteStream(0xa1, 0xb1, 0xdf);
  93         decoder.decode(is);
  94         assertEquals("[ST][RW]a1b1df[CH]\uff61\uff71\uff9f[EN]", lst.toString());
  95
  96         return;
  97     }
  98
  99     @Test
 100     public void testJisX0208() throws Exception{
 101         DecodeNotifier decoder;
 102         TestListener lst;
 103         InputStream is;
 104
 105         decoder = new SjisNotifier();
 106
 107         lst = new TestListenerRW();
 108         decoder.setCharDecodeListener(lst);
 109
 110         // test JISX0208 ASCII decoding
 111
 112         lst.clear();
 113         is = Bseq.byteStream(0x88, 0x9f, 0xea, 0xa4);
 114         decoder.decode(is);
 115         assertEquals("[ST][RW]889feaa4[CH]\u4e9c\u7199[EN]", lst.toString());
 116
 117         return;
 118     }
 119
 120     @Test
 121     public void testInvalid1st() throws Exception{
 122         DecodeNotifier decoder;
 123         TestListener lst;
 124         InputStream is;
 125
 126         decoder = new SjisNotifier();
 127
 128         lst = new TestListenerRW();
 129         decoder.setCharDecodeListener(lst);
 130
 131         // test invalid 1st character decoding
 132         // 0x80, 0xa0, 0xf0 - 0xff
 133
 134         lst.clear();
 135         is = Bseq.byteStream(0x80);
 136         decoder.decode(is);
 137         assertEquals("[ST][ME]80[EN]", lst.toString());
 138
 139         lst.clear();
 140         is = Bseq.byteStream(0x80, 0x41);
 141         decoder.decode(is);
 142         assertEquals("[ST][ME]80[RW]41[CH]A[EN]", lst.toString());
 143
 144         // 0x80+あ
 145         lst.clear();
 146         is = Bseq.byteStream(0x80, 0x82, 0xa0);
 147         decoder.decode(is);
 148         assertEquals("[ST][ME]80[RW]82a0[CH]\u3042[EN]", lst.toString());
 149
 150         lst.clear();
 151         is = Bseq.byteStream(0x80, 0x80);
 152         decoder.decode(is);
 153         assertEquals("[ST][ME]80[ME]80[EN]", lst.toString());
 154
 155         lst.clear();
 156         is = Bseq.byteStream(0xa0);
 157         decoder.decode(is);
 158         assertEquals("[ST][ME]a0[EN]", lst.toString());
 159
 160         lst.clear();
 161         is = Bseq.byteStream(0xf0);
 162         decoder.decode(is);
 163         assertEquals("[ST][ME]f0[EN]", lst.toString());
 164
 165         lst.clear();
 166         is = Bseq.byteStream(0xff);
 167         decoder.decode(is);
 168         assertEquals("[ST][ME]ff[EN]", lst.toString());
 169
 170         lst.clear();
 171         is = Bseq.byteStream(0xfd, 0xfe, 0xff);
 172         decoder.decode(is);
 173         assertEquals("[ST][ME]fd[ME]fe[ME]ff[EN]", lst.toString());
 174
 175         lst.clear();
 176         is = Bseq.byteStream(0xff, 0x32);
 177         decoder.decode(is);
 178         assertEquals("[ST][ME]ff[RW]32[CH]2[EN]", lst.toString());
 179
 180         lst.clear();
 181         is = Bseq.byteStream(0x41, 0x42, 0x43, 0xff, 0x32);
 182         decoder.decode(is);
 183         assertEquals("[ST][RW]414243[CH]ABC[ME]ff[RW]32[CH]2[EN]", lst.toString());
 184
 185         return;
 186     }
 187
 188     @Test
 189     public void testInvalid2nd() throws Exception{
 190         DecodeNotifier decoder;
 191         TestListener lst;
 192         InputStream is;
 193
 194         decoder = new SjisNotifier();
 195
 196         lst = new TestListenerRW();
 197         decoder.setCharDecodeListener(lst);
 198
 199         // test invalid 2nd character decoding
 200         // 0x00 - 0x3f, 0x7f, 0xfd - 0xff
 201
 202         lst.clear();
 203         is = Bseq.byteStream(0x81, 0x00);
 204         decoder.decode(is);
 205         assertEquals("[ST][ME]81[RW]00[CH]\u0000[EN]", lst.toString());
 206
 207         lst.clear();
 208         is = Bseq.byteStream(0x81, 0x3f);
 209         decoder.decode(is);
 210         assertEquals("[ST][ME]81[RW]3f[CH]\u003f[EN]", lst.toString());
 211
 212         lst.clear();
 213         is = Bseq.byteStream(0x81, 0x7f);
 214         decoder.decode(is);
 215 //        assertEquals("[ST][RW]817f[CH]\u00f7[EN]", lst.toString()); // 1.7
 216 //        assertEquals("[ST][ME]81[RW]7f[CH]\u007f[EN]", lst.toString()); // 1.8
 217
 218         lst.clear();
 219         is = Bseq.byteStream(0x81, 0xfd);
 220         decoder.decode(is);
 221         assertEquals("[ST][ME]81[ME]fd[EN]", lst.toString());
 222
 223         lst.clear();
 224         is = Bseq.byteStream(0x81, 0xfe);
 225         decoder.decode(is);
 226         assertEquals("[ST][ME]81[ME]fe[EN]", lst.toString());
 227
 228         lst.clear();
 229         is = Bseq.byteStream(0x81, 0xff);
 230         decoder.decode(is);
 231         assertEquals("[ST][ME]81[ME]ff[EN]", lst.toString());
 232
 233         return;
 234     }
 235
 236     @Test
 237     public void testUnmap() throws Exception{
 238         DecodeNotifier decoder;
 239         TestListener lst;
 240         InputStream is;
 241
 242         decoder = new SjisNotifier(4, 4);
 243
 244         lst = new TestListenerRW();
 245         decoder.setCharDecodeListener(lst);
 246
 247         // test unmap error
 248
 249         lst.clear();
 250         is = Bseq.byteStream(0x85, 0x40);
 251         decoder.decode(is);
 252         assertEquals("[ST][UE]8540[EN]", lst.toString());
 253
 254         lst.clear();
 255         is = Bseq.byteStream(0x41, 0x42, 0x43, 0x85, 0x40);
 256         decoder.decode(is);
 257         assertEquals("[ST][RW]414243[CH]ABC[UE]8540[EN]", lst.toString());
 258
 259         return;
 260     }
 261
 262     @Test
 263     public void testSomeMethod() throws Exception{
 264         DecodeNotifier decoder;
 265         TestListener lst;
 266         InputStream is;
 267
 268         // test decoding
 269
 270         decoder = new SjisNotifier();
 271
 272         lst = new TestListenerRW();
 273         decoder.setCharDecodeListener(lst);
 274
 275         lst.clear();
 276         is = Bseq.byteStream();
 277         decoder.decode(is);
 278         assertEquals("[ST][EN]", lst.toString());
 279
 280         lst.clear();
 281         is = Bseq.byteStream(0x41);
 282         decoder.decode(is);
 283         assertEquals("[ST][RW]41[CH]A[EN]", lst.toString());
 284
 285         return;
 286     }
 287
 288 }