cadi/core/src/test/java/org/onap/aaf/cadi/test/JU_BufferedServletInputStream.java

   1 /*******************************************************************************
   2  * ============LICENSE_START====================================================
   3  * * org.onap.aaf
   4  * * ===========================================================================
   5  * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
   6  * * ===========================================================================
   7  * * Licensed under the Apache License, Version 2.0 (the "License");
   8  * * you may not use this file except in compliance with the License.
   9  * * You may obtain a copy of the License at
  10  * *
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0
  12  * *
  13  *  * Unless required by applicable law or agreed to in writing, software
  14  * * distributed under the License is distributed on an "AS IS" BASIS,
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * * See the License for the specific language governing permissions and
  17  * * limitations under the License.
  18  * * ============LICENSE_END====================================================
  19  * *
  20  * *
  21  ******************************************************************************/
  22 package org.onap.aaf.cadi.test;
  23
  24 import java.io.ByteArrayInputStream;
  25 import java.io.FileNotFoundException;
  26 import java.io.IOException;
  27 import java.lang.reflect.*;
  28 import junit.framework.Assert;
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.onap.aaf.cadi.BufferedServletInputStream;
  33
  34 import static junit.framework.Assert.assertEquals;
  35
  36 public class JU_BufferedServletInputStream {
  37         private BufferedServletInputStream bsis;
  38         private String expected;
  39
  40         @Before
  41         public void setup() throws FileNotFoundException {
  42                 expected = new String("This is the expected output");
  43                 bsis = new BufferedServletInputStream(new ByteArrayInputStream(expected.getBytes()));
  44         }
  45
  46         @After
  47         public void tearDown() throws IOException {
  48                 bsis.close();
  49         }
  50
  51         @Test
  52         public void ByteReadNoMarkTest() throws Exception {
  53                 int c;
  54                 int i = 0;
  55                 byte output[] = new byte[100];
  56                 while ((c = bsis.read()) != -1) {
  57                         output[i++] = (byte)c;
  58                 }
  59                 Assert.assertEquals(new String(output, 0, i), expected);
  60         }
  61
  62         @Test
  63         public void ByteReadMarkTest() throws Exception {
  64                 bsis.mark(0);
  65                 int c;
  66                 int i = 0;
  67                 byte output[] = new byte[100];
  68                 while ((c = bsis.read()) != -1) {
  69                         output[i++] = (byte)c;
  70                 }
  71                 Assert.assertEquals(new String(output, 0, i), expected);
  72         }
  73
  74         @Test
  75         public void ByteReadStateIsStoreTest() throws Exception {
  76                 Field state_field = BufferedServletInputStream.class.getDeclaredField("state");
  77                 state_field.setAccessible(true);
  78                 bsis.mark(0);
  79                 int c;
  80                 int i = 0;
  81                 byte output[] = new byte[100];
  82                 while ((c = bsis.read()) != -1) {
  83                         output[i++] = (byte)c;
  84                 }
  85                 bsis.reset();
  86                 Assert.assertEquals(state_field.get(bsis), 2);  // state == READ
  87         }
  88
  89         @Test
  90         public void ByteReadStateIsReadTest() throws Exception {
  91                 bsis.mark(0);  // Initialize the capacitor
  92                 boolean isReset = false;
  93                 int c;
  94                 int i = 0;
  95                 byte output[] = new byte[100];
  96                 while ((c = bsis.read()) != -1) {
  97                         output[i++] = (byte)c;
  98                         if ((i > 5) && !isReset) {
  99                                 // Close the capacitor and start over. This is done for coverage purposes
 100                                 i = 0;
 101                                 isReset = true;
 102                                 bsis.reset();  // Sets state to READ
 103                         }
 104                 }
 105                 Assert.assertEquals(new String(output, 0, i), expected);
 106         }
 107
 108         @Test
 109         public void ByteReadStateIsNoneTest() throws Exception {
 110                 Field state_field = BufferedServletInputStream.class.getDeclaredField("state");
 111                 state_field.setAccessible(true);
 112                 bsis.mark(0);  // Initialize the capacitor
 113                 int c;
 114                 c = bsis.read();
 115                 // Close the capacitor. This is done for coverage purposes
 116                 bsis.reset();  // Sets state to READ
 117                 state_field.setInt(bsis, 0);  // state == NONE
 118                 c = bsis.read();
 119                 Assert.assertEquals(c, -1);
 120         }
 121
 122         @Test
 123         public void ByteArrayReadNoMarkTest() throws Exception {
 124                 byte output[] = new byte[100];
 125                 int count = bsis.read(output, 0, expected.length());
 126                 Assert.assertEquals(new String(output, 0, count), expected);
 127                 Assert.assertEquals(count, expected.length());
 128         }
 129
 130     @Test
 131     public void ByteArrayReadTest() throws Exception {
 132         byte[] output = new byte[100];
 133         bsis.mark(0);
 134         bsis.read(output);
 135         Assert.assertEquals(new String(output, 0, expected.length()), expected);
 136     }
 137
 138         @Test
 139         public void ByteArrayReadStateIsStoreTest() throws Exception {
 140                 byte output[] = new byte[100];
 141                 bsis.mark(0);
 142                 int count = bsis.read(output, 0, expected.length());
 143                 Assert.assertEquals(new String(output, 0, count), expected);
 144                 Assert.assertEquals(count, expected.length());
 145
 146                 count = bsis.read(output, 0, 0);
 147                 Assert.assertEquals(count, -1);
 148         }
 149
 150         @Test
 151         public void ByteArrayReadStateIsReadTest() throws Exception {
 152                 byte output[] = new byte[200];
 153                 for(int i = 0; i < 2; ++i) {
 154                         bsis.mark(0);
 155                         bsis.read(output, 0, 100);
 156             Assert.assertEquals(new String(output, 0, expected.length()), expected);
 157
 158                         bsis.reset();
 159                         bsis.read(output, 0, output.length);
 160             Assert.assertEquals(new String(output, 0, expected.length()), expected);
 161                         bsis = new BufferedServletInputStream(new ByteArrayInputStream(output));
 162                         if(i == 0) {
 163                                 output = new byte[200];
 164                         }
 165                 }
 166
 167         Assert.assertEquals(new String(output, 0, expected.length()), expected);
 168         }
 169
 170         @Test
 171         public void ByteArrayReadStateIsNoneTest() throws Exception {
 172         byte output[] = new byte[100];
 173         bsis.mark(0);
 174
 175         Field state_field = BufferedServletInputStream.class.getDeclaredField("state");
 176                 state_field.setAccessible(true);
 177         state_field.setInt(bsis, 0);  // state == NONE
 178
 179         int count = bsis.read(output, 0, 100);
 180         Assert.assertEquals(count, -1);
 181         }
 182
 183     @Test
 184     public void skipTest() throws Exception {
 185         byte output[] = new byte[100];
 186         bsis.mark(0);
 187         bsis.read(output, 0, 10);
 188         long count = bsis.skip(200);
 189         // skip returns the number left _before_ skipping. that number starts at 256
 190         Assert.assertEquals(count, 246);
 191
 192         count = bsis.skip(200);
 193         Assert.assertEquals(count, 17);
 194     }
 195
 196     @Test
 197     public void availableTest() throws Exception {
 198         int count = bsis.available();
 199         Assert.assertEquals(count, 27);
 200         bsis.mark(0);
 201         count = bsis.available();
 202         Assert.assertEquals(count, 27);
 203     }
 204
 205     @Test
 206     public void bufferedTest() throws Exception {
 207         bsis.mark(0);
 208         Assert.assertEquals(bsis.buffered(), 0);
 209     }
 210
 211     @Test
 212     public void closeTest() throws Exception {
 213                 Field capacitor_field = BufferedServletInputStream.class.getDeclaredField("capacitor");
 214                 capacitor_field.setAccessible(true);
 215         bsis.mark(0);
 216         Assert.assertNotNull(capacitor_field.get(bsis));
 217         bsis.close();
 218                 Assert.assertNull(capacitor_field.get(bsis));
 219     }
 220
 221         @Test
 222         public void markTest() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
 223                 Field state_field = BufferedServletInputStream.class.getDeclaredField("state");
 224                 Field capacitor_field = BufferedServletInputStream.class.getDeclaredField("capacitor");
 225                 capacitor_field.setAccessible(true);
 226                 state_field.setAccessible(true);
 227
 228                 // capacitor is null initially
 229                 Assert.assertNull(capacitor_field.get(bsis));
 230
 231                 state_field.setInt(bsis, 0);  // state == NONE
 232                 bsis.mark(0);  // the value passed into mark is ignored
 233                 Assert.assertNotNull(capacitor_field.get(bsis));
 234                 Assert.assertEquals(state_field.get(bsis), 1);  // state == STORE
 235
 236                 state_field.setInt(bsis, 1);  // state == STORE
 237                 bsis.mark(0);  // the value passed into mark is ignored
 238                 Assert.assertEquals(state_field.get(bsis), 1);  // state == STORE
 239
 240                 state_field.setInt(bsis, 2);  // state == READ
 241                 bsis.mark(0);  // the value passed into mark is ignored
 242                 Assert.assertEquals(state_field.get(bsis), 1);  // state == STORE
 243         }
 244
 245     @Test
 246     public void resetTest() throws Exception {
 247                 Field state_field = BufferedServletInputStream.class.getDeclaredField("state");
 248                 state_field.setAccessible(true);
 249
 250         bsis.mark(0);
 251         Assert.assertEquals(state_field.get(bsis), 1);  // state == STORE
 252         bsis.reset();
 253         Assert.assertEquals(state_field.get(bsis), 2);  // state == READ
 254         bsis.reset();
 255         Assert.assertEquals(state_field.get(bsis), 2);  // state == READ
 256
 257                 state_field.setInt(bsis, -1);  // state is invalid
 258         bsis.reset();  // This call does nothing. It is for coverage alone
 259         Assert.assertEquals(state_field.get(bsis), -1);  // state doesn't change
 260
 261         try {
 262             state_field.setInt(bsis, 0);  // state == NONE
 263             bsis.reset();
 264         } catch (IOException e) {
 265             Assert.assertEquals(e.getMessage(), "InputStream has not been marked");
 266         }
 267     }
 268
 269     @Test
 270     public void markSupportedTest() {
 271         Assert.assertTrue(bsis.markSupported());
 272     }
 273
 274         // "Bug" 4/22/2013
 275         // Some XML code expects Buffered InputStream can never return 0...  This isn't actually true, but we'll accommodate as far
 276         // as we can.
 277         // Here, we make sure we set and read the Buffered data, making sure the buffer is empty on the last test...
 278         @Test
 279         public void issue04_22_2013() throws IOException {
 280                 String testString = "We want to read in and get out with a Buffered Stream seamlessly.";
 281                 ByteArrayInputStream bais = new ByteArrayInputStream(testString.getBytes());
 282                 BufferedServletInputStream bsis = new BufferedServletInputStream(bais);
 283                 try {
 284                         bsis.mark(0);
 285                         byte aa[] = new byte[testString.length()];  // 65 count... important for our test (divisible by 5);
 286
 287                         int read;
 288                         for(int i=0;i<aa.length;i+=5) {
 289                                 read = bsis.read(aa, i, 5);
 290                                 assertEquals(5,read);
 291                         }
 292                         // System.out.println(new String(aa));
 293
 294                         bsis.reset();
 295
 296                         byte bb[] = new byte[aa.length];
 297                         read = 0;
 298                         for(int i=0;read>=0;i+=read) {
 299                                 read = bsis.read(bb,i,5);
 300                                 switch(i) {
 301                                         case 65:
 302                                                 assertEquals(read,-1);
 303                                                 break;
 304                                         default:
 305                                                 assertEquals(read,5);
 306                                 }
 307                         }
 308                         // System.out.println(new String(bb));
 309                         assertEquals(testString,new String(aa));
 310                         assertEquals(testString,new String(bb));
 311
 312                 } finally {
 313                         bsis.close();
 314                         bais.close();
 315                 }
 316
 317         }
 318
 319
 320 }