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

   1 package be.nikiroo.utils.test_code;
   2
   3 import java.io.ByteArrayInputStream;
   4 import java.io.InputStream;
   5
   6 import be.nikiroo.utils.IOUtils;
   7 import be.nikiroo.utils.streams.ReplaceInputStream;
   8 import be.nikiroo.utils.test.TestCase;
   9 import be.nikiroo.utils.test.TestLauncher;
  10
  11 class ReplaceInputStreamTest extends TestLauncher {
  12         public ReplaceInputStreamTest(String[] args) {
  13                 super("ReplaceInputStream test", args);
  14
  15                 addTest(new TestCase("Empty replace") {
  16                         @Override
  17                         public void test() throws Exception {
  18                                 byte[] data = new byte[] { 42, 12, 0, 127 };
  19                                 ReplaceInputStream in = new ReplaceInputStream(
  20                                                 new ByteArrayInputStream(data), new byte[0],
  21                                                 new byte[0]);
  22
  23                                 checkArrays(this, "FIRST", in, data);
  24                         }
  25                 });
  26
  27                 addTest(new TestCase("Simple replace") {
  28                         @Override
  29                         public void test() throws Exception {
  30                                 byte[] data = new byte[] { 42, 12, 0, 127 };
  31                                 ReplaceInputStream in = new ReplaceInputStream(
  32                                                 new ByteArrayInputStream(data), new byte[] { 0 },
  33                                                 new byte[] { 10 });
  34
  35                                 checkArrays(this, "FIRST", in, new byte[] { 42, 12, 10, 127 });
  36                         }
  37                 });
  38
  39                 addTest(new TestCase("3/4 replace") {
  40                         @Override
  41                         public void test() throws Exception {
  42                                 byte[] data = new byte[] { 42, 12, 0, 127 };
  43                                 ReplaceInputStream in = new ReplaceInputStream(
  44                                                 new ByteArrayInputStream(data),
  45                                                 new byte[] { 12, 0, 127 }, new byte[] { 10, 10, 10 });
  46
  47                                 checkArrays(this, "FIRST", in, new byte[] { 42, 10, 10, 10 });
  48                         }
  49                 });
  50
  51                 addTest(new TestCase("Longer replace") {
  52                         @Override
  53                         public void test() throws Exception {
  54                                 byte[] data = new byte[] { 42, 12, 0, 127 };
  55                                 ReplaceInputStream in = new ReplaceInputStream(
  56                                                 new ByteArrayInputStream(data), new byte[] { 0 },
  57                                                 new byte[] { 10, 10, 10 });
  58
  59                                 checkArrays(this, "FIRST", in, new byte[] { 42, 12, 10, 10, 10,
  60                                                 127 });
  61                         }
  62                 });
  63
  64                 addTest(new TestCase("Shorter replace") {
  65                         @Override
  66                         public void test() throws Exception {
  67                                 byte[] data = new byte[] { 42, 12, 0, 127 };
  68                                 ReplaceInputStream in = new ReplaceInputStream(
  69                                                 new ByteArrayInputStream(data),
  70                                                 new byte[] { 42, 12, 0 }, new byte[] { 10 });
  71
  72                                 checkArrays(this, "FIRST", in, new byte[] { 10, 127 });
  73                         }
  74                 });
  75
  76                 addTest(new TestCase("String replace") {
  77                         @Override
  78                         public void test() throws Exception {
  79                                 byte[] data = "I like red".getBytes("UTF-8");
  80                                 ReplaceInputStream in = new ReplaceInputStream(
  81                                                 new ByteArrayInputStream(data),
  82                                                 "red", "blue");
  83
  84                                 checkArrays(this, "FIRST", in, "I like blue".getBytes("UTF-8"));
  85
  86                                 data = "I like blue".getBytes("UTF-8");
  87                                 in = new ReplaceInputStream(new ByteArrayInputStream(data),
  88                                                 "blue", "red");
  89
  90                                 checkArrays(this, "FIRST", in, "I like red".getBytes("UTF-8"));
  91                         }
  92                 });
  93
  94                 addTest(new TestCase("Multiple replaces") {
  95                         @Override
  96                         public void test() throws Exception {
  97                                 byte[] data = "I like red".getBytes("UTF-8");
  98                                 ReplaceInputStream in = new ReplaceInputStream(
  99                                                 new ByteArrayInputStream(data), //
 100                                                 new String[] {"like", "red"}, //
 101                                                 new String[] {"dislike", "green"} //
 102                                 );
 103
 104                                 String result = new String(IOUtils.toByteArray(in), "UTF-8");
 105                                 assertEquals("I dislike green", result);
 106                         }
 107                 });
 108         }
 109
 110         static void checkArrays(TestCase test, String prefix, InputStream in,
 111                         byte[] expected) throws Exception {
 112                 byte[] actual = IOUtils.toByteArray(in);
 113                 test.assertEquals("The " + prefix
 114                                 + " resulting array has not the correct number of items",
 115                                 expected.length, actual.length);
 116                 for (int i = 0; i < actual.length; i++) {
 117                         test.assertEquals("Item " + i + " (0-based) is not the same",
 118                                         expected[i], actual[i]);
 119                 }
 120         }
 121 }