src/be/nikiroo/utils/test_code/NextableInputStreamTest.java

   1 package be.nikiroo.utils.test_code;
   2
   3 import java.io.ByteArrayInputStream;
   4
   5 import be.nikiroo.utils.IOUtils;
   6 import be.nikiroo.utils.streams.NextableInputStream;
   7 import be.nikiroo.utils.streams.NextableInputStreamStep;
   8 import be.nikiroo.utils.test.TestCase;
   9 import be.nikiroo.utils.test.TestLauncher;
  10
  11 public class NextableInputStreamTest extends TestLauncher {
  12         public NextableInputStreamTest(String[] args) {
  13                 super("NextableInputStream test", args);
  14
  15                 addTest(new TestCase("Simple byte array reading") {
  16                         @Override
  17                         public void test() throws Exception {
  18                                 byte[] expected = new byte[] { 42, 12, 0, 127 };
  19                                 NextableInputStream in = new NextableInputStream(
  20                                                 new ByteArrayInputStream(expected), null);
  21                                 checkNext(this, "READ", in, expected);
  22                         }
  23                 });
  24
  25                 addTest(new TestCase("Stop at 12") {
  26                         @Override
  27                         public void test() throws Exception {
  28                                 byte[] expected = new byte[] { 42, 12, 0, 127 };
  29                                 NextableInputStream in = new NextableInputStream(
  30                                                 new ByteArrayInputStream(expected),
  31                                                 new NextableInputStreamStep(12));
  32
  33                                 checkNext(this, "FIRST", in, new byte[] { 42 });
  34                         }
  35                 });
  36
  37                 addTest(new TestCase("Stop at 12, resume, stop again, resume") {
  38                         @Override
  39                         public void test() throws Exception {
  40                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
  41                                 NextableInputStream in = new NextableInputStream(
  42                                                 new ByteArrayInputStream(data),
  43                                                 new NextableInputStreamStep(12));
  44
  45                                 checkNext(this, "FIRST", in, new byte[] { 42 });
  46                                 checkNext(this, "SECOND", in, new byte[] { 0, 127 });
  47                                 checkNext(this, "THIRD", in, new byte[] { 51, 11 });
  48                         }
  49                 });
  50
  51                 addTest(new TestCase("Encapsulation") {
  52                         @Override
  53                         public void test() throws Exception {
  54                                 byte[] data = new byte[] { 42, 12, 0, 4, 127, 12, 5 };
  55                                 NextableInputStream in4 = new NextableInputStream(
  56                                                 new ByteArrayInputStream(data),
  57                                                 new NextableInputStreamStep(4));
  58                                 NextableInputStream subIn12 = new NextableInputStream(in4,
  59                                                 new NextableInputStreamStep(12));
  60
  61                                 in4.next();
  62                                 checkNext(this, "SUB FIRST", subIn12, new byte[] { 42 });
  63                                 checkNext(this, "SUB SECOND", subIn12, new byte[] { 0 });
  64
  65                                 assertEquals("The subIn still has some data", false,
  66                                                 subIn12.next());
  67
  68                                 checkNext(this, "MAIN LAST", in4, new byte[] { 127, 12, 5 });
  69                         }
  70                 });
  71
  72                 addTest(new TestCase("UTF-8 text lines test") {
  73                         @Override
  74                         public void test() throws Exception {
  75                                 String ln1 = "Ligne première";
  76                                 String ln2 = "Ligne la deuxième du nom";
  77                                 byte[] data = (ln1 + "\n" + ln2).getBytes("UTF-8");
  78                                 NextableInputStream in = new NextableInputStream(
  79                                                 new ByteArrayInputStream(data),
  80                                                 new NextableInputStreamStep('\n'));
  81
  82                                 checkNext(this, "FIRST", in, ln1.getBytes("UTF-8"));
  83                                 checkNext(this, "SECOND", in, ln2.getBytes("UTF-8"));
  84                         }
  85                 });
  86
  87                 addTest(new TestCase("nextAll()") {
  88                         @Override
  89                         public void test() throws Exception {
  90                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
  91                                 NextableInputStream in = new NextableInputStream(
  92                                                 new ByteArrayInputStream(data),
  93                                                 new NextableInputStreamStep(12));
  94
  95                                 checkNext(this, "FIRST", in, new byte[] { 42 });
  96                                 checkNextAll(this, "REST", in, new byte[] { 0, 127, 12, 51, 11,
  97                                                 12 });
  98                                 assertEquals("The stream still has some data", false, in.next());
  99                         }
 100                 });
 101
 102                 addTest(new TestCase("getBytesRead()") {
 103                         @Override
 104                         public void test() throws Exception {
 105                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
 106                                 NextableInputStream in = new NextableInputStream(
 107                                                 new ByteArrayInputStream(data),
 108                                                 new NextableInputStreamStep(12));
 109
 110                                 in.nextAll();
 111                                 IOUtils.toByteArray(in);
 112
 113                                 assertEquals("The number of bytes read is not correct",
 114                                                 data.length, in.getBytesRead());
 115                         }
 116                 });
 117
 118                 addTest(new TestCase("bytes array input") {
 119                         @Override
 120                         public void test() throws Exception {
 121                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
 122                                 NextableInputStream in = new NextableInputStream(data,
 123                                                 new NextableInputStreamStep(12));
 124
 125                                 checkNext(this, "FIRST", in, new byte[] { 42 });
 126                                 checkNext(this, "SECOND", in, new byte[] { 0, 127 });
 127                                 checkNext(this, "THIRD", in, new byte[] { 51, 11 });
 128                         }
 129                 });
 130
 131                 addTest(new TestCase("Skip data") {
 132                         @Override
 133                         public void test() throws Exception {
 134                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
 135                                 NextableInputStream in = new NextableInputStream(data, null);
 136                                 in.next();
 137
 138                                 byte[] rest = new byte[] { 12, 51, 11, 12 };
 139
 140                                 in.skip(4);
 141                                 assertEquals("STARTS_WITH OK_1", true, in.startsWith(rest));
 142                                 assertEquals("STARTS_WITH KO_1", false,
 143                                                 in.startsWith(new byte[] { 0 }));
 144                                 assertEquals("STARTS_WITH KO_2", false, in.startsWith(data));
 145                                 assertEquals("STARTS_WITH KO_3", false,
 146                                                 in.startsWith(new byte[] { 1, 2, 3 }));
 147                                 assertEquals("STARTS_WITH OK_2", true, in.startsWith(rest));
 148                                 assertEquals("READ REST", IOUtils.readSmallStream(in),
 149                                                 new String(rest));
 150                                 in.close();
 151                         }
 152                 });
 153
 154                 addTest(new TestCase("Starts with") {
 155                         @Override
 156                         public void test() throws Exception {
 157                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
 158                                 NextableInputStream in = new NextableInputStream(data, null);
 159                                 in.next();
 160
 161                                 // yes
 162                                 assertEquals("It actually starts with that", true,
 163                                                 in.startsWith(new byte[] { 42 }));
 164                                 assertEquals("It actually starts with that", true,
 165                                                 in.startsWith(new byte[] { 42, 12 }));
 166                                 assertEquals("It actually is the same array", true,
 167                                                 in.startsWith(data));
 168
 169                                 // no
 170                                 assertEquals("It actually does not start with that", false,
 171                                                 in.startsWith(new byte[] { 12 }));
 172                                 assertEquals(
 173                                                 "It actually does not start with that",
 174                                                 false,
 175                                                 in.startsWith(new byte[] { 42, 12, 0, 127, 12, 51, 11,
 176                                                                 11 }));
 177
 178                                 // too big
 179                                 assertEquals(
 180                                                 "A search term bigger than the whole data cannot be found in the data",
 181                                                 false, in.startsWith(new byte[] { 42, 12, 0, 127, 12,
 182                                                                 51, 11, 12, 0 }));
 183
 184                                 in.close();
 185                         }
 186                 });
 187
 188                 addTest(new TestCase("Starts with strings") {
 189                         @Override
 190                         public void test() throws Exception {
 191                                 String text = "Fanfan et Toto vont à la mer";
 192                                 byte[] data = text.getBytes("UTF-8");
 193                                 NextableInputStream in = new NextableInputStream(data, null);
 194                                 in.next();
 195
 196                                 // yes
 197                                 assertEquals("It actually starts with that", true,
 198                                                 in.startsWith("F"));
 199                                 assertEquals("It actually starts with that", true,
 200                                                 in.startsWith("Fanfan et"));
 201                                 assertEquals("It actually is the same text", true,
 202                                                 in.startsWith(text));
 203
 204                                 // no
 205                                 assertEquals("It actually does not start with that", false,
 206                                                 in.startsWith("Toto"));
 207                                 assertEquals("It actually does not start with that", false,
 208                                                 in.startsWith("Fanfan et Toto vont à la mee"));
 209
 210                                 // too big
 211                                 assertEquals(
 212                                                 "A search term bigger than the whole data cannot be found in the data",
 213                                                 false, in.startsWith("Fanfan et Toto vont à la mer."));
 214
 215                                 in.close();
 216                         }
 217                 });
 218
 219                 addTest(new TestCase("Starts With strings + steps") {
 220                         @Override
 221                         public void test() throws Exception {
 222                                 String data = "{\nREF: fanfan\n}";
 223                                 NextableInputStream in = new NextableInputStream(
 224                                                 data.getBytes("UTF-8"), new NextableInputStreamStep(
 225                                                                 '\n'));
 226                                 in.next();
 227
 228                                 assertEquals("STARTS_WITH OK", true, in.startsWith("{"));
 229                                 in.skip(1);
 230                                 assertEquals("STARTS_WITH WHEN SPENT", false,
 231                                                 in.startsWith("{"));
 232
 233                                 checkNext(this, "PARTIAL CONTENT", in,
 234                                                 "REF: fanfan".getBytes("UTF-8"));
 235                         }
 236                 });
 237
 238                 addTest(new TestCase("InputStream is(String)") {
 239                         @Override
 240                         public void test() throws Exception {
 241                                 String data = "{\nREF: fanfan\n}";
 242                                 NextableInputStream in = new NextableInputStream(
 243                                                 new ByteArrayInputStream(data.getBytes("UTF-8")),
 244                                                 new NextableInputStreamStep('\n'));
 245
 246                                 in.next();
 247                                 assertEquals("Item 1 OK", true, in.is("{"));
 248                                 assertEquals("Item 1 KO_1", false, in.is("|"));
 249                                 assertEquals("Item 1 KO_2", false, in.is("{}"));
 250                                 in.skip(1);
 251                                 in.next();
 252                                 assertEquals("Item 2 OK", true, in.is("REF: fanfan"));
 253                                 assertEquals("Item 2 KO", false, in.is("REF: fanfan."));
 254                                 IOUtils.readSmallStream(in);
 255                                 in.next();
 256                                 assertEquals("Item 3 OK", true, in.is("}"));
 257
 258                                 in.close();
 259                         }
 260                 });
 261
 262                 addTest(new TestCase("Bytes NextAll test") {
 263                         @Override
 264                         public void test() throws Exception {
 265                                 byte[] data = new byte[] { 42, 12, 0, 127, 12, 51, 11, 12 };
 266                                 NextableInputStream in = new NextableInputStream(
 267                                                 new ByteArrayInputStream(data),
 268                                                 new NextableInputStreamStep(12));
 269
 270                                 checkNext(this, "FIRST", in, new byte[] { 42 });
 271                                 checkNextAll(this, "SECOND", in, new byte[] { 0, 127, 12, 51,
 272                                                 11, 12 });
 273                         }
 274                 });
 275
 276                 addTest(new TestCase("String NextAll test") {
 277                         @Override
 278                         public void test() throws Exception {
 279                                 String d1 = "^java.lang.String";
 280                                 String d2 = "\"http://example.com/query.html\"";
 281                                 String data = d1 + ":" + d2;
 282                                 NextableInputStream in = new NextableInputStream(
 283                                                 new ByteArrayInputStream(data.getBytes("UTF-8")),
 284                                                 new NextableInputStreamStep(':'));
 285
 286                                 checkNext(this, "FIRST", in, d1.getBytes("UTF-8"));
 287                                 checkNextAll(this, "SECOND", in, d2.getBytes("UTF-8"));
 288                         }
 289                 });
 290
 291                 addTest(new TestCase("NextAll in Next test") {
 292                         @Override
 293                         public void test() throws Exception {
 294                                 String line1 = "première ligne";
 295                                 String d1 = "^java.lang.String";
 296                                 String d2 = "\"http://example.com/query.html\"";
 297                                 String line3 = "end of lines";
 298                                 String data = line1 + "\n" + d1 + ":" + d2 + "\n" + line3;
 299
 300                                 NextableInputStream inL = new NextableInputStream(
 301                                                 new ByteArrayInputStream(data.getBytes("UTF-8")),
 302                                                 new NextableInputStreamStep('\n'));
 303
 304                                 checkNext(this, "Line 1", inL, line1.getBytes("UTF-8"));
 305                                 inL.next();
 306
 307                                 NextableInputStream in = new NextableInputStream(inL,
 308                                                 new NextableInputStreamStep(':'));
 309
 310                                 checkNext(this, "Line 2 FIRST", in, d1.getBytes("UTF-8"));
 311                                 checkNextAll(this, "Line 2 SECOND", in, d2.getBytes("UTF-8"));
 312                         }
 313                 });
 314         }
 315
 316         static void checkNext(TestCase test, String prefix, NextableInputStream in,
 317                         byte[] expected) throws Exception {
 318                 test.assertEquals("Cannot get " + prefix + " entry", true, in.next());
 319                 checkArrays(test, prefix, in, expected);
 320         }
 321
 322         static void checkNextAll(TestCase test, String prefix,
 323                         NextableInputStream in, byte[] expected) throws Exception {
 324                 test.assertEquals("Cannot get " + prefix + " entries", true,
 325                                 in.nextAll());
 326                 checkArrays(test, prefix, in, expected);
 327         }
 328
 329         static void checkArrays(TestCase test, String prefix,
 330                         NextableInputStream in, byte[] expected) throws Exception {
 331                 byte[] actual = IOUtils.toByteArray(in);
 332                 test.assertEquals("The " + prefix
 333                                 + " resulting array has not the correct number of items",
 334                                 expected.length, actual.length);
 335                 for (int i = 0; i < actual.length; i++) {
 336                         test.assertEquals("Item " + i + " (0-based) is not the same",
 337                                         expected[i], actual[i]);
 338                 }
 339         }
 340 }