Java Code Examples for java.io.ByteArrayOutputStream

/** 
 * Convert legacy XML ("version 0") to schema v1 compliant XML.
 * @param xml Legacy XML input stream.
 * @return Schema v1 compliant XML.
 */
public static InputStream transformLegacyXML(InputStream xml) throws TransformerException, IOException {
  System.setProperty("javax.xml.transform.TransformerFactory","net.sf.saxon.TransformerFactoryImpl");
  TransformerFactory tFactory=TransformerFactory.newInstance();
  InputStream xsltFile=JAXBConvertor.class.getResourceAsStream("transform-0-1.xslt");
  ByteArrayOutputStream os=new ByteArrayOutputStream();
  javax.xml.transform.Source xmlSource=new javax.xml.transform.stream.StreamSource(xml);
  javax.xml.transform.Source xsltSource=new javax.xml.transform.stream.StreamSource(xsltFile);
  javax.xml.transform.Result result=new javax.xml.transform.stream.StreamResult(os);
  javax.xml.transform.Transformer trans=tFactory.newTransformer(xsltSource);
  trans.transform(xmlSource,result);
  os.close();
  return new ByteArrayInputStream(os.toByteArray());
}
 

private String extractHunk(RawText rawText,int startLine,int endLine){
  try {
    ByteArrayOutputStream bas=new ByteArrayOutputStream();
    for (int line=startLine; line < endLine; ++line) {
      rawText.writeLine(bas,line);
      bas.write('\n');
    }
    return new String(bas.toByteArray(),"utf-8");
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
}
 

@Test public void writeAndRead() throws IOException {
  PrimeNumbersWritable original=new PrimeNumbersWritable(2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97);
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  original.write(new DataOutputStream(out));
  PrimeNumbersWritable clone=new PrimeNumbersWritable();
  clone.readFields(new DataInputStream(new ByteArrayInputStream(out.toByteArray())));
  assertEquals(original,clone);
}
 

@GET @Produces(MediaType.APPLICATION_JSON) @Path("/viewer") @Timed public Response prettyPrintOneLine(@QueryParam("object") final String object) throws IOException {
  final ByteArrayOutputStream out=new ByteArrayOutputStream();
  final ObjectMapper mapper=new ObjectMapper();
  final String objectURIDecoded=URLDecoder.decode(object,"UTF-8");
  final byte[] objectBase64Decoded=Base64.decodeBase64(objectURIDecoded.getBytes());
  mapper.configure(SerializationFeature.INDENT_OUTPUT,true);
  final LinkedHashMap map=mapper.readValue(new String(objectBase64Decoded),LinkedHashMap.class);
  mapper.writeValue(out,map);
  return Response.ok().entity(new String(out.toByteArray())).build();
}
 

/** 
 * Reads a null-terminate string
 * @param in
 * @param charset
 * @return
 * @throws IOException
 */
public static String readString(InputStream in,String charset) throws IOException {
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  int c;
  while ((c=in.read()) > 0) {
    out.write(c);
  }
  return new String(out.toByteArray(),charset);
}
 

public byte[] zippedSession(Session session) throws IOException {
  ByteArrayOutputStream byteStream=new ByteArrayOutputStream();
  Base64OutputStream base64OutputStream=new Base64OutputStream(byteStream);
  GZIPOutputStream gzip=new GZIPOutputStream(base64OutputStream);
  OutputStreamWriter writer=new OutputStreamWriter(gzip);
  gson.toJson(session,session.getClass(),writer);
  writer.flush();
  gzip.finish();
  writer.close();
  return byteStream.toByteArray();
}
 

@Test public void testEventSerializer() throws Exception {
  JsonEventSerializer eventSerializer=new JsonEventSerializer(FixedDummyEventClass.class);
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  JsonGenerator jsonGenerator=new JsonFactory().createJsonGenerator(out,JsonEncoding.UTF8);
  FixedDummyEventClass event=TestingUtils.getEvents().get(0);
  eventSerializer.serialize(event,jsonGenerator);
  String json=out.toString(Charsets.UTF_8.name());
  assertEquals(json,TestingUtils.getNormalizedJson("event.json"));
}
 

/** 
 * Crops an image based on the value of the top left pixel.
 * @param data The image data.
 * @param fuzziness The fuzziness allowed for minor deviations (~5 is recommended).
 * @return The new image data, cropped.
 * @throws IOException If the image could not be read.
 */
public static byte[] autoCrop(final byte[] data,final int fuzziness) throws IOException {
  final BufferedImage image=ImageIO.read(new ByteArrayInputStream(data));
  final BufferedImage cropped=autoCrop(image,fuzziness);
  final ByteArrayOutputStream out=new ByteArrayOutputStream();
  ImageIO.write(cropped,"png",out);
  return out.toByteArray();
}
 

/** 
 * Converts an array of Scan objects into a base64 string
 * @param scans
 * @return
 * @throws IOException
 */
public static String convertScanArrayToString(final Scan[] scans) throws IOException {
  final ByteArrayOutputStream baos=new ByteArrayOutputStream();
  final DataOutputStream dos=new DataOutputStream(baos);
  ArrayWritable aw=new ArrayWritable(Scan.class,scans);
  aw.write(dos);
  return Base64.encodeBytes(baos.toByteArray());
}
 

private void createBytes(Serializable ser) throws IOException {
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  ObjectOutputStream out=new ObjectOutputStream(baos);
  out.writeObject(ser);
  out.flush();
  this.objSer=baos.toByteArray();
}
 

private <F>F serializeDeserialize(F futureResult) throws IOException, ClassNotFoundException {
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  ObjectOutputStream objectOutputStream=new ObjectOutputStream(out);
  objectOutputStream.writeObject(futureResult);
  objectOutputStream.close();
  ByteArrayInputStream in=new ByteArrayInputStream(out.toByteArray());
  ObjectInputStream objectInputStream=new ObjectInputStream(in);
  F f=(F)objectInputStream.readObject();
  assertNotNull(f);
  return f;
}
 

public ByteArrayOutputStream compress() throws IOException {
  BufferedInputStream in=new BufferedInputStream(input);
  ByteArrayOutputStream bos=new ByteArrayOutputStream();
  DeflaterOutputStream out=new DeflaterOutputStream(bos,new Deflater(),BUF_SIZE);
  byte[] buf=new byte[BUF_SIZE];
  for (int count=in.read(buf); count != -1; count=in.read(buf)) {
    out.write(buf,0,count);
  }
  in.close();
  out.flush();
  out.close();
  return bos;
}
 

public void _writeChildBoxes(ByteBuffer bb){
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  WritableByteChannel wbc=Channels.newChannel(baos);
  try {
    for (    Box box : boxes) {
      box.getBox(wbc);
    }
    wbc.close();
  }
 catch (  IOException e) {
    throw new RuntimeException("Cannot happen. Everything should be in memory and therefore no exceptions.");
  }
  bb.put(baos.toByteArray());
}
 

public InputStream getContent() throws IOException, IllegalStateException {
  if (!isRepeatable() && this.contentConsumed) {
    throw new IllegalStateException("Content has been consumed");
  }
  this.contentConsumed=true;
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  Part.sendParts(baos,this.parts,this.multipartBoundary);
  ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
  return bais;
}
 

protected String encodeCookie(SerializableCookie cookie){
  ByteArrayOutputStream os=new ByteArrayOutputStream();
  try {
    ObjectOutputStream outputStream=new ObjectOutputStream(os);
    outputStream.writeObject(cookie);
  }
 catch (  Exception e) {
    return null;
  }
  return byteArrayToHexString(os.toByteArray());
}
 

public byte[] toByteArray() throws IOException {
  ByteArrayOutputStream baos=new ByteArrayOutputStream(512);
  DataOutputStream dos=new DataOutputStream(baos);
  dos.write(NameUtil.toByteArray(this.name));
  dos.writeShort(type.getValue());
  dos.writeShort(clazz.getValue());
  dos.flush();
  return baos.toByteArray();
}
 

@RequestMapping(value="/person/{id}",method=RequestMethod.GET,headers="Accept=image/jpeg, image/jpg, image/png, image/gif") public @ResponseBody byte[] getPhoto(@PathVariable("id") Long id){
  try {
    InputStream is=this.getClass().getResourceAsStream("/bella.jpg");
    BufferedImage img=ImageIO.read(is);
    ByteArrayOutputStream bao=new ByteArrayOutputStream();
    ImageIO.write(img,"jpg",bao);
    logger.debug("Retrieving photo as byte array image");
    return bao.toByteArray();
  }
 catch (  IOException e) {
    logger.error(e);
    throw new RuntimeException(e);
  }
}
 

private void publishImage(){
  Bitmap bmp=((BitmapDrawable)getResources().getDrawable(R.drawable.ic_app)).getBitmap();
  ByteArrayOutputStream stream=new ByteArrayOutputStream();
  bmp.compress(Bitmap.CompressFormat.JPEG,100,stream);
  byte[] bitmapdata=stream.toByteArray();
  facebook.publishImage(bitmapdata,Constants.FACEBOOK_SHARE_IMAGE_CAPTION);
}
 

/** 
 * Doubles the size of a bitmap and re-reads it with samplesize 2. I've  found no other way to smoothely resize images with samplesize = 1.
 * @param source
 * @return
 */
private Bitmap blowup(Bitmap source){
  if (source != null) {
    Bitmap big=Bitmap.createScaledBitmap(source,source.getWidth() * 2,source.getHeight() * 2,true);
    BitmapFactory.Options opts=new BitmapFactory.Options();
    opts.inSampleSize=2;
    ByteArrayOutputStream os=new ByteArrayOutputStream();
    big.compress(CompressFormat.PNG,100,os);
    byte[] array=os.toByteArray();
    return BitmapFactory.decodeByteArray(array,0,array.length,opts);
  }
  return null;
}
 

public static byte[] toBytes(InputStream is){
  byte[] result=null;
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  try {
    copy(is,baos);
    result=baos.toByteArray();
  }
 catch (  IOException e) {
    AQUtility.report(e);
  }
  close(is);
  return result;
}
 

public static byte[] serialize(Serializable obj) throws IOException {
  final ByteArrayOutputStream bos=new ByteArrayOutputStream();
  final ObjectOutputStream oos=new ObjectOutputStream(bos);
  oos.writeObject(obj);
  return bos.toByteArray();
}
 

/** 
 * Gets the size of the provided area code map storage. The map storage passed-in will be filled as a result.
 */
private static int getSizeOfAreaCodeMapStorage(AreaCodeMapStorageStrategy mapStorage,SortedMap<Integer,String> areaCodeMap) throws IOException {
  mapStorage.readFromSortedMap(areaCodeMap);
  ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
  ObjectOutputStream objectOutputStream=new ObjectOutputStream(byteArrayOutputStream);
  mapStorage.writeExternal(objectOutputStream);
  objectOutputStream.flush();
  int sizeOfStorage=byteArrayOutputStream.size();
  objectOutputStream.close();
  return sizeOfStorage;
}
 

private ByteArrayEntity getCompressedEntity(byte[] data) throws IOException {
  ByteArrayEntity entity;
  if (data.length >= MIN_GZIP_SIZE) {
    ByteArrayOutputStream byteOutput=new ByteArrayOutputStream(data.length / 2);
    GZIPOutputStream gzipOutput=new GZIPOutputStream(byteOutput);
    gzipOutput.write(data);
    gzipOutput.close();
    entity=new ByteArrayEntity(byteOutput.toByteArray());
  }
 else {
    entity=new ByteArrayEntity(data);
  }
  return entity;
}
 

public static NdefRecord newImageRecord(Bitmap bitmap){
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  bitmap.compress(Bitmap.CompressFormat.JPEG,100,out);
  byte[] content=out.toByteArray();
  return MimeRecord.newMimeRecord("image/jpeg",content);
}
 

/** 
 * Compress data.
 * @param bytesToCompress is the byte array to compress.
 * @return a compressed byte array.
 * @throws java.io.IOException
 */
public static byte[] compress(byte[] bytesToCompress) throws IOException {
  Deflater compressor=new Deflater(Deflater.BEST_COMPRESSION);
  compressor.setInput(bytesToCompress);
  compressor.finish();
  ByteArrayOutputStream bos=new ByteArrayOutputStream(bytesToCompress.length);
  byte[] buf=new byte[bytesToCompress.length + 100];
  while (!compressor.finished()) {
    bos.write(buf,0,compressor.deflate(buf));
  }
  bos.close();
  return bos.toByteArray();
}
 

@Override public Component createComponent(VisualizerInput vis,Application application){
  AutoHeightIFrame iframe;
  ApplicationResource resource;
  ByteArrayOutputStream outStream=new ByteArrayOutputStream();
  writeOutput(vis,outStream);
  resource=vis.getVisPanel().createResource(outStream,getContentType());
  String url=vis.getVisPanel().getApplication().getRelativeLocation(resource);
  iframe=new AutoHeightIFrame(url == null ? "/error.html" : url);
  return iframe;
}
 

@Test public void test() throws IOException {
  String[] row=new String[]{"1","2","","3"};
  String s=on("\t").join(row) + "\n";
  s+=s;
  Table table=new Table();
  table.addRow(asList(row));
  table.addRow(asList(row));
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  new TsvGenerator(table).generate(out);
  String s1=out.toString(UTF_8.name());
  assertEquals(s,s1);
  String s2=new TsvGenerator(table).generateString();
  assertEquals(s,s2);
}
 

/** 
 * Copies the content from the given input stream to the file. <p> This method closes the input stream after copying it
 * @param fileName The filename that is relative to the root of the test environment
 * @param inputStream The inputStream to read from
 * @return The file that has been createad
 * @throws IOException
 */
public File createFile(String fileName,InputStream inputStream) throws IOException {
  ByteArrayOutputStream output=new ByteArrayOutputStream();
  byte[] buffer=new byte[1024];
  int bytesRead=-1;
  while ((bytesRead=inputStream.read(buffer,0,buffer.length)) != -1) {
    output.write(buffer,0,bytesRead);
  }
  Utilities.close(inputStream);
  return createFile(fileName,output.toString());
}
 

public String readStream() throws IOException {
  final ByteArrayOutputStream baos=new ByteArrayOutputStream();
  InputStream is=openInputStream();
  try {
    int c;
    while ((c=is.read()) != -1) {
      baos.write(c);
    }
  }
  finally {
    is.close();
  }
  return new String(baos.toByteArray());
}
 

static String invokeExec(String cmd,String... args){
  ByteArrayOutputStream b=new ByteArrayOutputStream();
  PrintStream prev=System.out;
  try {
    PrintStream p=new PrintStream(b);
    System.setOut(p);
    exec(cmd,args).execute();
    p.close();
  }
  finally {
    System.setOut(prev);
  }
  return b.toString();
}
 

static private String readAll(InputStream in,String encoding) throws IOException {
  ByteArrayOutputStream raw=new ByteArrayOutputStream();
  byte buffer[]=new byte[1 << 16];
  int n=0;
  while ((n=in.read(buffer)) != -1) {
    raw.write(buffer,0,n);
  }
  if (encoding == null) {
    encoding="utf8";
  }
  return raw.toString(encoding);
}
 

protected String imageToBase64Png(BufferedImage image){
  ByteArrayOutputStream rawPngStream=new ByteArrayOutputStream();
  try {
    if (!writeImageAsPng(image,rawPngStream)) {
      throw new RuntimeException("This Java environment does not support converting to PNG.");
    }
  }
 catch (  IOException exception) {
    Throwables.propagate(exception);
  }
  byte[] rawPngBytes=rawPngStream.toByteArray();
  return new Base64Encoder().encode(rawPngBytes);
}
 

static void writeBitmap(ContentValues values,String name,Bitmap bitmap){
  if (bitmap != null) {
    int size=bitmap.getWidth() * bitmap.getHeight() * 2;
    ByteArrayOutputStream out=new ByteArrayOutputStream(size);
    try {
      bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
      out.flush();
      out.close();
      values.put(name,out.toByteArray());
    }
 catch (    IOException e) {
    }
  }
}
 

private void writeWARCInfo(OutputStream recOut,MetaData md) throws IOException {
  String filename=JSONUtils.extractSingle(md,"Container.Filename");
  if (filename == null) {
    throw new IOException("No Container.Filename...");
  }
  HttpHeaders headers=new HttpHeaders();
  headers.add("Software-Info",IAUtils.COMMONS_VERSION);
  headers.addDateHeader("Extracted-Date",new Date());
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  headers.write(baos);
  recW.writeWARCInfoRecord(recOut,filename,baos.toByteArray());
}
 

@Override public byte[] compress(byte[] value,int offset,int length) throws IOException {
  ByteArrayOutputStream baos=new ByteArrayOutputStream(MathUtils.nextPowOfTwo(length));
  try (OutputStream out=new GZIPOutputStream(baos)){
    out.write(value,offset,length);
  }
  finally {
    IoUtils.close(baos);
  }
  return baos.toByteArray();
}
 

void save(Writer w) throws IOException {
  if (expired)   return;
  w.write(id);
  w.write(':');
  w.write(Integer.toString(inactiveInterval));
  w.write(':');
  w.write(servletContext == null || servletContext.getServletContextName() == null ? "" : servletContext.getServletContextName());
  w.write(':');
  w.write(Long.toString(lastAccessTime));
  w.write("\r\n");
  Enumeration<String> e=getAttributeNames();
  ByteArrayOutputStream os=new ByteArrayOutputStream(1024 * 16);
  while (e.hasMoreElements()) {
    String aname=(String)e.nextElement();
    Object so=get(aname);
    if (so instanceof Serializable) {
      os.reset();
      ObjectOutputStream oos=new ObjectOutputStream(os);
      try {
        oos.writeObject(so);
        w.write(aname);
        w.write(":");
        w.write(Utils.base64Encode(os.toByteArray()));
        w.write("\r\n");
      }
 catch (      IOException ioe) {
        servletContext.log("Can't replicate/store a session value of '" + aname + "' class:"+ so.getClass().getName(),ioe);
      }
    }
 else     servletContext.log("Non serializable session object has been " + so.getClass().getName() + " skiped in storing of "+ aname,null);
    if (so instanceof HttpSessionActivationListener)     ((HttpSessionActivationListener)so).sessionWillPassivate(new HttpSessionEvent((HttpSession)this));
  }
  w.write("$$\r\n");
}
 

@Test public void shouldNotBreakIfListenerThrowsException() throws IOException {
class BadEventListener implements CacheEventListener {
    public void onFlush(    CacheEvent event){
      throw new RuntimeException("I'm a bad, baaad listener....");
    }
  }
  BadEventListener listener=new BadEventListener();
  Registry.cacheManager().addCacheEventListener(listener);
  PrintStream errOrig=System.err;
  ByteArrayOutputStream bout=new ByteArrayOutputStream();
  PrintStream err=new PrintStream(bout);
  System.setErr(err);
  Person.createIt("name","Matt","last_name","Diamont","dob","1962-01-01");
  err.flush();
  bout.flush();
  String exception=bout.toString();
  a(exception.contains(" I'm a bad, baaad listener")).shouldBeTrue();
  System.setErr(errOrig);
}
 

protected void assertMarshalBooleans(int count,BooleanValueSet valueSet) throws Exception {
  BooleanStream bs=new BooleanStream();
  for (int i=0; i < count; i++) {
    bs.writeBoolean(valueSet.getBooleanValueFor(i,count));
  }
  ByteArrayOutputStream buffer=new ByteArrayOutputStream();
  DataOutputStream ds=new DataOutputStream(buffer);
  bs.marshal(ds);
  ds.writeInt(endOfStreamMarker);
  ds.close();
  ByteArrayInputStream in=new ByteArrayInputStream(buffer.toByteArray());
  DataInputStream dis=new DataInputStream(in);
  bs=new BooleanStream();
  try {
    bs.unmarshal(dis);
  }
 catch (  Exception e) {
    e.printStackTrace();
    fail("Failed to unmarshal: " + count + " booleans: "+ e);
  }
  for (int i=0; i < count; i++) {
    boolean expected=valueSet.getBooleanValueFor(i,count);
    try {
      boolean actual=bs.readBoolean();
      assertEquals("value of object: " + i + " was: "+ actual,expected,actual);
    }
 catch (    IOException e) {
      e.printStackTrace();
      fail("Failed to parse boolean: " + i + " out of: "+ count+ " due to: "+ e);
    }
  }
  int marker=dis.readInt();
  assertEquals("Marker int when unmarshalling: " + count + " booleans",Integer.toHexString(endOfStreamMarker),Integer.toHexString(marker));
  try {
    byte value=dis.readByte();
    fail("Should have reached the end of the stream");
  }
 catch (  IOException e) {
  }
}
 

public OutputStream receiveUpload(String filename,String mimeType){
  this.fileName=filename;
  this.mimeType=mimeType;
  this.outputStream=new ByteArrayOutputStream();
  return outputStream;
}
 

@Override public boolean downloadFeed(){
  boolean downloadSuccess=false;
  if (connectionService.isConnected()) {
    InputStream inputStream=null;
    try {
      final HttpGet httpget=new HttpGet(new URI(Const.FEED_URL));
      final HttpResponse response=new DefaultHttpClient().execute(httpget);
      final StatusLine status=response.getStatusLine();
      if (status.getStatusCode() != HttpStatus.SC_OK) {
        Ln.e("Erreur lors du t??hargement:%s,%s",status.getStatusCode(),status.getReasonPhrase());
      }
 else {
        final HttpEntity entity=response.getEntity();
        inputStream=entity.getContent();
        final ByteArrayOutputStream content=new ByteArrayOutputStream();
        int readBytes=0;
        final byte[] sBuffer=new byte[512];
        while ((readBytes=inputStream.read(sBuffer)) != -1) {
          content.write(sBuffer,0,readBytes);
        }
        final String dataAsString=new String(content.toByteArray());
        final List<FeedItem> syndFeed=rssService.parseRss(dataAsString);
        if (syndFeed != null) {
          databaseService.save(dataAsString);
          downloadSuccess=true;
        }
      }
    }
 catch (    final Throwable t) {
      Ln.e(t);
    }
 finally {
      closeQuietly(inputStream);
    }
  }
  return downloadSuccess;
}
 

final static public Image loadImage(final String fileName){
  String keyName=fileName.trim().toLowerCase();
  Image cacheImage=(Image)cacheImages.get(keyName);
  if (cacheImage == null) {
    InputStream in=new BufferedInputStream(classLoader.getResourceAsStream(fileName));
    ByteArrayOutputStream byteArrayOutputStream=new ByteArrayOutputStream();
    try {
      byte[] bytes=new byte[8192];
      int read;
      while ((read=in.read(bytes)) >= 0) {
        byteArrayOutputStream.write(bytes,0,read);
      }
      byte[] arrayByte=byteArrayOutputStream.toByteArray();
      cacheImages.put(keyName,cacheImage=toolKit.createImage(arrayByte));
      mediaTracker.addImage(cacheImage,0);
      mediaTracker.waitForID(0);
      waitImage(100,cacheImage);
    }
 catch (    Exception e) {
      throw new RuntimeException(fileName + " not found!");
    }
 finally {
      try {
        if (byteArrayOutputStream != null) {
          byteArrayOutputStream.close();
          byteArrayOutputStream=null;
        }
        if (in != null) {
          in.close();
        }
      }
 catch (      IOException e) {
      }
    }
  }
  if (cacheImage == null) {
    throw new RuntimeException(("File not found. ( " + fileName + " )").intern());
  }
  return cacheImage;
}
 

@Test public void testStatementSerialization() throws Exception {
  testCon.add(bob,name,nameBob);
  Statement st;
  RepositoryResult<Statement> statements=testCon.getStatements(null,null,null,true);
  try {
    st=statements.next();
  }
  finally {
    statements.close();
  }
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  ObjectOutputStream out=new ObjectOutputStream(baos);
  out.writeObject(st);
  out.close();
  ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
  ObjectInputStream in=new ObjectInputStream(bais);
  Statement deserializedStatement=(Statement)in.readObject();
  in.close();
  assertTrue(st.equals(deserializedStatement));
  assertTrue(testCon.hasStatement(st,true));
  assertTrue(testCon.hasStatement(deserializedStatement,true));
}
 

/** 
 * Managed OutputStreams should be tracked when open and forgotten when closed.
 */
@Test(dependsOnGroups={"init"}) public void testManageOutputStream() throws Exception {
  OutputStream managed=manager.manageOutputStream(null,new ByteArrayOutputStream());
  assertEquals(manager.getOpenOutputStreamCount(),1);
  managed.close();
  assertEquals(manager.getOpenOutputStreamCount(),0);
}
 

public final void saveOptionsToRMS(){
  if (bookURL != null && !bookURL.equalsIgnoreCase("")) {
    try {
      ByteArrayOutputStream boas=new ByteArrayOutputStream();
      DataOutputStream dout=new DataOutputStream(boas);
      try {
        RMSHelper.writeVersionNumber(this,dout);
        dout.writeUTF(bookURL);
        dout.writeUTF(dictsFolder);
        byte[] data=boas.toByteArray();
        if (rs.getNumRecords() > 0) {
          rs.setRecord(1,data,0,data.length);
        }
 else {
          rs.addRecord(data,0,data.length);
        }
      }
 catch (      IOException ioe) {
      }
    }
 catch (    RecordStoreException rse) {
    }
  }
}
 

@Test public void executesQueryWithoutErrors(){
  context.checking(new Expectations(){
{
      oneOf(queryService).findAll(0,MAX_RECORDS);
      will(returnValue(RESULT_LIST));
    }
  }
);
  PrintStream sysOut=System.out;
  try {
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    System.setOut(new PrintStream(baos));
    ListCatapults.executeQuery(queryService);
    Assert.assertTrue("Output contains Catapult name",baos.toString().contains(CATAPULT_NAME));
  }
  finally {
    System.setOut(sysOut);
  }
}
 

/** 
 * reads the file and transforms it in a payload
 * @param path path of the file
 * @param name name as which the payload should be saved
 * @return a payload
 */
private static Payload readFile(String path,Payload payload){
  InputStream inputStream=null;
  try {
    inputStream=new FileInputStream(path);
  }
 catch (  FileNotFoundException e) {
    e.printStackTrace();
  }
  ByteArrayOutputStream byteBuffer=new ByteArrayOutputStream();
  byte[] buffer=new byte[BUFFER_SIZE];
  int readBytes=0;
  try {
    while (true) {
      readBytes=inputStream.read(buffer);
      if (readBytes > 0) {
        byteBuffer.write(buffer,0,readBytes);
      }
 else {
        break;
      }
    }
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
  payload.setContent(byteBuffer.toByteArray());
  return payload;
}
 

private Object instantiateUsingSerialization(Class type){
  try {
    byte[] data;
    if (serializedDataCache.containsKey(type)) {
      data=(byte[])serializedDataCache.get(type);
    }
 else {
      ByteArrayOutputStream bytes=new ByteArrayOutputStream();
      DataOutputStream stream=new DataOutputStream(bytes);
      stream.writeShort(ObjectStreamConstants.STREAM_MAGIC);
      stream.writeShort(ObjectStreamConstants.STREAM_VERSION);
      stream.writeByte(ObjectStreamConstants.TC_OBJECT);
      stream.writeByte(ObjectStreamConstants.TC_CLASSDESC);
      stream.writeUTF(type.getName());
      stream.writeLong(ObjectStreamClass.lookup(type).getSerialVersionUID());
      stream.writeByte(2);
      stream.writeShort(0);
      stream.writeByte(ObjectStreamConstants.TC_ENDBLOCKDATA);
      stream.writeByte(ObjectStreamConstants.TC_NULL);
      data=bytes.toByteArray();
      serializedDataCache.put(type,data);
    }
    ObjectInputStream in=new ObjectInputStream(new ByteArrayInputStream(data));
    return in.readObject();
  }
 catch (  IOException e) {
    throw new ObjectAccessException("Cannot create " + type.getName() + " by JDK serialization",e);
  }
catch (  ClassNotFoundException e) {
    throw new ObjectAccessException("Cannot find class " + e.getMessage());
  }
}
 

public long saveCharInfo(long id,String name,FFXICharacter charInfo){
  byte[] chardata;
  charInfo.reload();
  try {
    ObjectOutputStream oos;
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    ;
    oos=new ObjectOutputStream(baos);
    oos.writeObject(charInfo);
    oos.close();
    chardata=baos.toByteArray();
    baos.close();
  }
 catch (  IOException e) {
    return -1;
  }
  return saveCharInfo(id,name,chardata,charInfo.getMeritPointId());
}
 

public MD5InputStreamResult generateMD5Result(InputStream toEncode){
  MD5Digest eTag=new MD5Digest();
  byte[] resBuf=new byte[eTag.getDigestSize()];
  byte[] buffer=new byte[1024];
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  long length=0;
  int numRead=-1;
  try {
    do {
      numRead=toEncode.read(buffer);
      if (numRead > 0) {
        length+=numRead;
        eTag.update(buffer,0,numRead);
        out.write(buffer,0,numRead);
      }
    }
 while (numRead != -1);
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
 finally {
    Closeables.closeQuietly(out);
    Closeables.closeQuietly(toEncode);
  }
  eTag.doFinal(resBuf,0);
  return new MD5InputStreamResult(out.toByteArray(),resBuf,length);
}
 

public static byte[] getBytesFromFile(InputStream is){
  try {
    ByteArrayOutputStream buffer=new ByteArrayOutputStream();
    int nRead;
    byte[] data=new byte[16384];
    while ((nRead=is.read(data,0,data.length)) != -1) {
      buffer.write(data,0,nRead);
    }
    buffer.flush();
    return buffer.toByteArray();
  }
 catch (  IOException e) {
    Log.e("com.eggie5.post_to_eggie5",e.toString());
    return null;
  }
}
 

public synchronized String getUrlContent(String url) throws ApiException {
  if (sUserAgent == null) {
    throw new ApiException("User-Agent string must be prepared");
  }
  HttpClient client=CreateClient();
  java.net.URI uri=URI.create(url);
  HttpHost host=GetHost(uri);
  HttpGet request=new HttpGet(uri.getPath());
  request.setHeader("User-Agent",sUserAgent);
  try {
    HttpResponse response=client.execute(host,request);
    StatusLine status=response.getStatusLine();
    Log.i(cTag,"get with response " + status.toString());
    if (status.getStatusCode() != HttpStatus.SC_OK) {
      throw new ApiException("Invalid response from server: " + status.toString());
    }
    HttpEntity entity=response.getEntity();
    InputStream inputStream=entity.getContent();
    ByteArrayOutputStream content=new ByteArrayOutputStream();
    int readBytes;
    while ((readBytes=inputStream.read(sBuffer)) != -1) {
      content.write(sBuffer,0,readBytes);
    }
    return new String(content.toByteArray());
  }
 catch (  IOException e) {
    throw new ApiException("Problem communicating with API",e);
  }
}
 

static String decompressZlib(byte[] bytes) throws IOException, DataFormatException {
  Inflater decompressor=new Inflater();
  decompressor.setInput(bytes);
  ByteArrayOutputStream out=new ByteArrayOutputStream();
  try {
    byte[] buf=new byte[1024];
    while (!decompressor.finished()) {
      int count=decompressor.inflate(buf);
      out.write(buf,0,count);
    }
  }
  finally {
    out.close();
  }
  return utf8(out.toByteArray());
}
 

private static void signWholeOutputFile(byte[] zipData,OutputStream outputStream,X509Certificate publicKey,PrivateKey privateKey) throws IOException, GeneralSecurityException {
  if (zipData[zipData.length - 22] != 0x50 || zipData[zipData.length - 21] != 0x4b || zipData[zipData.length - 20] != 0x05 || zipData[zipData.length - 19] != 0x06) {
    throw new IllegalArgumentException("zip data already has an archive comment");
  }
  Signature signature=Signature.getInstance("SHA1withRSA");
  signature.initSign(privateKey);
  signature.update(zipData,0,zipData.length - 2);
  ByteArrayOutputStream temp=new ByteArrayOutputStream();
  byte[] message="signed by SignApk".getBytes("UTF-8");
  temp.write(message);
  temp.write(0);
  writeSignatureBlock(signature,publicKey,temp);
  int total_size=temp.size() + 6;
  if (total_size > 0xffff) {
    throw new IllegalArgumentException("signature is too big for ZIP file comment");
  }
  int signature_start=total_size - message.length - 1;
  temp.write(signature_start & 0xff);
  temp.write((signature_start >> 8) & 0xff);
  temp.write(0xff);
  temp.write(0xff);
  temp.write(total_size & 0xff);
  temp.write((total_size >> 8) & 0xff);
  temp.flush();
  byte[] b=temp.toByteArray();
  for (int i=0; i < b.length - 3; ++i) {
    if (b[i] == 0x50 && b[i + 1] == 0x4b && b[i + 2] == 0x05 && b[i + 3] == 0x06) {
      throw new IllegalArgumentException("found spurious EOCD header at " + i);
    }
  }
  outputStream.write(zipData,0,zipData.length - 2);
  outputStream.write(total_size & 0xff);
  outputStream.write((total_size >> 8) & 0xff);
  temp.writeTo(outputStream);
}
 

/** 
 * Read an inline string from the stream
 * @return the String as parsed from the stream
 * @throws IOException
 */
private String readInlineString() throws IOException {
  ByteArrayOutputStream outputStream=new ByteArrayOutputStream(256);
  while (true) {
    int i=read();
    if (i == 0) {
      break;
    }
 else     if (i == EOF_BYTE) {
      throw new EofException();
    }
    outputStream.write(i);
  }
  outputStream.flush();
  String res=outputStream.toString("UTF-8");
  outputStream.close();
  return res;
}
 

/** 
 * Store the given bitmap in this database for the given appWidgetId.
 */
public boolean setPhoto(int appWidgetId,Bitmap bitmap){
  boolean success=false;
  try {
    int size=bitmap.getWidth() * bitmap.getHeight() * 4;
    ByteArrayOutputStream out=new ByteArrayOutputStream(size);
    bitmap.compress(Bitmap.CompressFormat.PNG,100,out);
    out.flush();
    out.close();
    ContentValues values=new ContentValues();
    values.put(PhotoDatabaseHelper.FIELD_APPWIDGET_ID,appWidgetId);
    values.put(PhotoDatabaseHelper.FIELD_PHOTO_BLOB,out.toByteArray());
    SQLiteDatabase db=getWritableDatabase();
    db.insertOrThrow(PhotoDatabaseHelper.TABLE_PHOTOS,null,values);
    success=true;
  }
 catch (  SQLiteException e) {
    Log.e(TAG,"Could not open database",e);
  }
catch (  IOException e) {
    Log.e(TAG,"Could not serialize photo",e);
  }
  if (LOGD) {
    Log.d(TAG,"setPhoto success=" + success);
  }
  return success;
}
 

public void setBookmark(Uri uri,int bookmark,int duration){
  try {
    BlobCache cache=CacheManager.getCache(mContext,BOOKMARK_CACHE_FILE,BOOKMARK_CACHE_MAX_ENTRIES,BOOKMARK_CACHE_MAX_BYTES,BOOKMARK_CACHE_VERSION);
    ByteArrayOutputStream bos=new ByteArrayOutputStream();
    DataOutputStream dos=new DataOutputStream(bos);
    dos.writeUTF(uri.toString());
    dos.writeInt(bookmark);
    dos.writeInt(duration);
    dos.flush();
    cache.insert(uri.hashCode(),bos.toByteArray());
  }
 catch (  Throwable t) {
    Log.w(TAG,"setBookmark failed",t);
  }
}
 

public byte[] toByteArray(){
  ByteArrayOutputStream buffer=new ByteArrayOutputStream(1024);
  DataOutputStream output=new DataOutputStream(buffer);
  try {
    output.writeByte(VERSION);
    output.writeInt(mNumMessages);
    for (int i=0; i < mNumMessages; i++) {
      output.writeByte(mActions[i]);
      byte[] bytes=mMessages[i].toByteArray();
      output.writeInt(bytes.length);
      output.write(bytes);
    }
  }
 catch (  java.io.IOException e) {
    return null;
  }
  return buffer.toByteArray();
}
 

public static byte[] serializeToByteArray(Serializable o){
  try {
    ByteArrayOutputStream bytes=new ByteArrayOutputStream();
    ObjectOutputStream out=new ObjectOutputStream(bytes);
    try {
      out.writeObject(o);
    }
  finally {
      out.close();
    }
    return bytes.toByteArray();
  }
 catch (  IOException e) {
    throw new RuntimeException("Can't serialize object: " + o,e);
  }
}
 

@Before public void setUp() throws Exception {
  List<Point> list=new ArrayList<Point>();
  list.add(new Point(0,0));
  list.add(new Point(0,100));
  list.add(new Point(100,0));
  list.add(new Point(100,100));
  polyline=new Polyline(list);
  exporter=new PolylineExporter();
  stream=new ByteArrayOutputStream();
}
 

public static <T extends Value>T valueOf(Class<T> clazz,InputStream in) throws IOException {
  ByteArrayOutputStream baos=new ByteArrayOutputStream();
  try {
    StreamUtils.copy(in,baos);
  }
  finally {
    IoUtils.close(baos);
  }
  try {
    Constructor<T> constructor=clazz.getConstructor(byte[].class);
    return constructor.newInstance(baos.toByteArray());
  }
 catch (  SecurityException e) {
    throw new IOException("SecurityException",e);
  }
catch (  NoSuchMethodException e) {
    throw new IOException("NoSuchMethodException",e);
  }
catch (  IllegalArgumentException e) {
    throw new IOException("IllegalArgumentException",e);
  }
catch (  InstantiationException e) {
    throw new IOException("InstantiationException",e);
  }
catch (  IllegalAccessException e) {
    throw new IOException("IllegalAccessException",e);
  }
catch (  InvocationTargetException e) {
    throw new IOException("InvocationTargetException",e);
  }
}
 

private void assertSerializable(RepositoryException e){
  try {
    ObjectOutputStream oos=new ObjectOutputStream(new ByteArrayOutputStream());
    oos.writeObject(e);
    oos.close();
  }
 catch (  IOException ioe) {
    throw new IllegalStateException(ioe);
  }
}
 

public void showWorking(final ByteArrayOutputStream waveBuffer,final int speechStartPosition,final int speechEndPosition){
  mUiHandler.post(new Runnable(){
    @Override public void run(){
      mState=WORKING;
      prepareDialog(mContext.getText(R.string.voice_working),null,mContext.getText(R.string.cancel));
      final ShortBuffer buf=ByteBuffer.wrap(waveBuffer.toByteArray()).order(ByteOrder.nativeOrder()).asShortBuffer();
      buf.position(0);
      waveBuffer.reset();
      showWave(buf,speechStartPosition / 2,speechEndPosition / 2);
    }
  }
);
}
 

public void showWorking(final ByteArrayOutputStream waveBuffer,final int speechStartPosition,final int speechEndPosition){
  mUiHandler.post(new Runnable(){
    @Override public void run(){
      mState=WORKING;
      prepareDialog(mContext.getText(R.string.voice_working),null,mContext.getText(R.string.cancel));
      final ShortBuffer buf=ByteBuffer.wrap(waveBuffer.toByteArray()).order(ByteOrder.nativeOrder()).asShortBuffer();
      buf.position(0);
      waveBuffer.reset();
      showWave(buf,speechStartPosition / 2,speechEndPosition / 2);
    }
  }
);
}