@Override public void proceed() { try { List<Pair<String, byte[]>> entryList = readZipEntries(src) .parallelStream() .map(this::transformClassBlob) .collect(Collectors.toList()); if (entryList.isEmpty()) return; try (OutputStream fileOut = Files.newOutputStream(dst)) { ByteArrayOutputStream buffer = zipEntries(entryList); buffer.writeTo(fileOut); } } catch (IOException e) { throw new RuntimeException("Reading jar entries failure", e); } }
private ByteArrayOutputStream zipEntries(List<Pair<String, byte[]>> entryList) throws IOException { ByteArrayOutputStream buffer = new ByteArrayOutputStream(8192); try (ZipOutputStream jar = new ZipOutputStream(buffer)) { jar.setMethod(ZipOutputStream.STORED); final CRC32 crc = new CRC32(); for (Pair<String, byte[]> entry : entryList) { byte[] bytes = entry.second; final ZipEntry newEntry = new ZipEntry(entry.first); newEntry.setMethod(ZipEntry.STORED); // chose STORED method crc.reset(); crc.update(entry.second); newEntry.setCrc(crc.getValue()); newEntry.setSize(bytes.length); writeEntryToJar(newEntry, bytes, jar); } jar.flush(); } return buffer; }
private String getResponseEntity(HttpResponse result) throws IOException { HttpEntity entity = result.getEntity(); if (entity == null) { log.debug("Null response entity"); return null; } try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); entity.writeTo(bos); byte[] bytes = bos.toByteArray(); if (bytes == null) { bytes = "null".getBytes(); } String response = new String(bytes); log.debug("Response with code " + result + ": " + response); return response; } finally { InputStream content = entity.getContent(); if (content != null) { content.close(); } } }
public static void main(String[] args) throws Exception { String cmd = "/tmp/test.sh"; CommandLine cmdLine = CommandLine.parse("/bin/bash " + cmd); ByteArrayOutputStream stdout = new ByteArrayOutputStream(); ByteArrayOutputStream stderr = new ByteArrayOutputStream(); PumpStreamHandler psh = new PumpStreamHandler(stdout, stderr); psh.setStopTimeout(TIMEOUT_FIVE_MINUTES); ExecuteWatchdog watchdog = new ExecuteWatchdog(TIMEOUT_TEN_MINUTES); // timeout in milliseconds Executor executor = new DefaultExecutor(); executor.setExitValue(0); executor.setStreamHandler(psh); executor.setWatchdog(watchdog); int exitValue = executor.execute(cmdLine, Collections.emptyMap()); System.out.println(exitValue); }
/** * Renders an input file (XML or XSL-FO) into a PDF file. It uses the JAXP * transformer given to optionally transform the input document to XSL-FO. * The transformer may be an identity transformer in which case the input * must already be XSL-FO. The PDF is written to a byte array that is * returned as the method's result. * @param src Input XML or XSL-FO * @param transformer Transformer to use for optional transformation * @param response HTTP response object * @throws FOPException If an error occurs during the rendering of the * XSL-FO * @throws TransformerException If an error occurs during XSL * transformation * @throws IOException In case of an I/O problem */ public void render(Source src, Transformer transformer, HttpServletResponse response, String realpath) throws FOPException, TransformerException, IOException { FOUserAgent foUserAgent = getFOUserAgent(realpath); //Setup output ByteArrayOutputStream out = new ByteArrayOutputStream(); //Setup FOP fopFactory.setBaseURL(realpath); Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, out); //Make sure the XSL transformation's result is piped through to FOP Result res = new SAXResult(fop.getDefaultHandler()); //Start the transformation and rendering process transformer.transform(src, res); //Return the result sendPDF(out.toByteArray(), response); }
@Override public void getNext(CAS aCAS) throws IOException, CollectionException { // nextTarEntry cannot be null here! ByteArrayOutputStream buffer = new ByteArrayOutputStream(); int size = IOUtils.copy(tarArchiveInputStream, buffer); String entryName = nextTarEntry.getName(); getLogger().debug("Loaded " + size + " bytes from " + entryName); // and move forward fastForwardToNextValidEntry(); // and now create JCas InputStream inputStream = new ByteArrayInputStream(buffer.toByteArray()); try { XmiCasDeserializer.deserialize(inputStream, aCAS, lenient); } catch (SAXException e) { throw new IOException(e); } }
@Test public void testSecureCopyFile() throws JSchException, IOException { final JschBuilder mockJschBuilder = mock(JschBuilder.class); final JSch mockJsch = mock(JSch.class); final Session mockSession = mock(Session.class); final ChannelExec mockChannelExec = mock(ChannelExec.class); final byte [] bytes = {0}; final ByteArrayOutputStream out = new ByteArrayOutputStream(); when(mockChannelExec.getInputStream()).thenReturn(new TestInputStream()); when(mockChannelExec.getOutputStream()).thenReturn(out); when(mockSession.openChannel(eq("exec"))).thenReturn(mockChannelExec); when(mockJsch.getSession(anyString(), anyString(), anyInt())).thenReturn(mockSession); when(mockJschBuilder.build()).thenReturn(mockJsch); when(Config.mockSshConfig.getJschBuilder()).thenReturn(mockJschBuilder); when(Config.mockRemoteCommandExecutorService.executeCommand(any(RemoteExecCommand.class))).thenReturn(mock(RemoteCommandReturnInfo.class)); final String source = BinaryDistributionControlServiceImplTest.class.getClassLoader().getResource("binarydistribution/copy.txt").getPath(); binaryDistributionControlService.secureCopyFile("someHost", source, "./build/tmp"); verify(Config.mockSshConfig).getJschBuilder(); assertEquals("C0644 12 copy.txt\nsome content\0", out.toString(StandardCharsets.UTF_8)); }
@Test public void testDownloadDataBlob() throws Exception { final URL jarLocation = getBlobFile(); InputStream openStream = null; try { // Get the JAR input openStream = jarLocation.openStream(); // Proceed to the test resource.prepareData(openStream, 1); final StreamingOutput downloadLobFile = resource.downloadLobFile(); final ByteArrayOutputStream output = new ByteArrayOutputStream(); downloadLobFile.write(output); org.junit.Assert.assertTrue(output.toByteArray().length > 3000000); } finally { IOUtils.closeQuietly(openStream); } }
/** * Clone a Protostuff object * * @param t the protobuf message to copy * @return a deep copy of {@code t} */ public static <T extends Message<T>> T copy(T t) { try { Schema<T> schema = t.cachedSchema(); ByteArrayOutputStream out = new ByteArrayOutputStream(); GraphIOUtil.writeDelimitedTo(new DataOutputStream(out), t, schema); // TODO: avoid array copy ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray()); T newMessage = schema.newMessage(); GraphIOUtil.mergeDelimitedFrom(in, newMessage, schema); return newMessage; } catch (IOException e) { throw UserException.dataReadError(e) .message("Failure decoding object, please ensure that you ran dremio-admin upgrade on Dremio.") .build(logger); } }
@Override byte[] encrypt(byte[] key, byte[] data) { try { SecretKeySpec keySpec = new SecretKeySpec(key, AES); cipher.init(Cipher.ENCRYPT_MODE, keySpec); byte[] ciphertext = cipher.doFinal(data); // Write out the metadata. ByteArrayOutputStream stream = new ByteArrayOutputStream(); DataOutput out = new DataOutputStream(stream); byte[] params = cipher.getParameters().getEncoded(); WritableUtils.writeVInt(out, params.length); out.write(params); // Write the original ciphertext and return the new ciphertext. out.write(ciphertext); return stream.toByteArray(); } catch (InvalidKeyException | IllegalBlockSizeException | BadPaddingException | IOException e) { throw new EncryptionException(e); } }
@Test public void getStatusHistory() throws Exception { final int subscription = getSubscription("MDA"); final StreamingOutput csv = (StreamingOutput) resource.getStatusHistory(subscription, "file1").getEntity(); final ByteArrayOutputStream out = new ByteArrayOutputStream(); csv.write(out); final BufferedReader inputStreamReader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(out.toByteArray()), "cp1252")); final String header = inputStreamReader.readLine(); Assert.assertEquals("issueid;key;author;from;to;fromText;toText;date;dateTimestamp", header); String lastLine = inputStreamReader.readLine(); Assert.assertEquals("11432;MDA-1;fdaugan;;1;;OPEN;2009/03/23 15:26:43;1237818403000", lastLine); lastLine = inputStreamReader.readLine(); Assert.assertEquals("11437;MDA-4;xsintive;;1;;OPEN;2009/03/23 16:23:31;1237821811000", lastLine); lastLine = inputStreamReader.readLine(); lastLine = inputStreamReader.readLine(); lastLine = inputStreamReader.readLine(); lastLine = inputStreamReader.readLine(); Assert.assertEquals("11535;MDA-8;challer;;1;;OPEN;2009/04/01 14:20:29;1238588429000", lastLine); lastLine = inputStreamReader.readLine(); lastLine = inputStreamReader.readLine(); lastLine = inputStreamReader.readLine(); Assert.assertEquals("11535;MDA-8;fdaugan;1;10024;OPEN;ASSIGNED;2009/04/09 09:45:16;1239263116000", lastLine); lastLine = inputStreamReader.readLine(); Assert.assertEquals("11535;MDA-8;fdaugan;10024;3;ASSIGNED;IN PROGRESS;2009/04/09 09:45:30;1239263130000", lastLine); }
@Test public void testReadByte() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); ByteBuffer buffer = ByteBuffer.allocate(10); for(int i = 0; i < "1,1.5,foo\n".length(); i++) buffer.put((byte)inStream.read()); assert(new String(buffer.array()).equals("1,1.5,foo\n")); assert(inStream.read() == -1); }
/** * Converts a BufferedInputStream to a byte array * * @param inputStream * @param bufferLength * @return * @throws IOException */ private byte[] convertBufferToBytes(BufferedInputStream inputStream, int bufferLength) throws IOException { if (inputStream == null) return null; ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); byte[] buffer = new byte[bufferLength]; int x = inputStream.read(buffer, 0, bufferLength); Log.i("GraphServiceController", "bytes read from picture input stream " + String.valueOf(x)); int n = 0; try { while ((n = inputStream.read(buffer, 0, bufferLength)) >= 0) { outputStream.write(buffer, 0, n); } inputStream.close(); } catch (IOException e) { e.printStackTrace(); } outputStream.close(); return outputStream.toByteArray(); }
public void send(COL_ONEM2M event) throws Exception { EncoderFactory avroEncoderFactory = EncoderFactory.get(); SpecificDatumWriter<COL_ONEM2M> avroEventWriter = new SpecificDatumWriter<COL_ONEM2M>(COL_ONEM2M.SCHEMA$); ByteArrayOutputStream stream = new ByteArrayOutputStream(); BinaryEncoder binaryEncoder = avroEncoderFactory.binaryEncoder(stream,null); try { avroEventWriter.write(event, binaryEncoder); binaryEncoder.flush(); } catch (IOException e) { e.printStackTrace(); throw e; } IOUtils.closeQuietly(stream); KeyedMessage<String, byte[]> data = new KeyedMessage<String, byte[]>( TOPIC, stream.toByteArray()); producer.send(data); }
public void send(COL_RDBMS event) throws Exception { EncoderFactory avroEncoderFactory = EncoderFactory.get(); SpecificDatumWriter<COL_RDBMS> avroEventWriter = new SpecificDatumWriter<COL_RDBMS>(COL_RDBMS.SCHEMA$); ByteArrayOutputStream stream = new ByteArrayOutputStream(); BinaryEncoder binaryEncoder = avroEncoderFactory.binaryEncoder(stream,null); try { avroEventWriter.write(event, binaryEncoder); binaryEncoder.flush(); } catch (IOException e) { e.printStackTrace(); throw e; } IOUtils.closeQuietly(stream); KeyedMessage<String, byte[]> data = new KeyedMessage<String, byte[]>( TOPIC, stream.toByteArray()); producer.send(data); }
protected String decompress(byte[] compressed) throws DataFormatException, IOException { Inflater decompresser = new Inflater(true); byte[] result = new byte[1024]; try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { decompresser.setInput(compressed); while (!decompresser.finished()) { int count = decompresser.inflate(result); out.write(result, 0, count); } decompresser.end(); return out.toString(); } }
@Test public void testInferenceMultipleWrites() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream iStream = new OptimizedInterceptedFileOutputStream(stream); iStream.write(new AugmentedString(1)); iStream.write(new AugmentedString(',')); iStream.write(new AugmentedString(1.5)); iStream.write(new AugmentedString(',')); iStream.write(new AugmentedString("foo")); iStream.write(new AugmentedString('\n')); CompositeVector vector = iStream.getVector(); assert (vector.getVectors().size() == 3); assert (vector.getVectors().get(0).getClass() == IntVector.class); assert (vector.getVectors().get(1).getClass() == Float8Vector.class); assert (vector.getVectors().get(2).getClass() == VarCharVector.class); }
@Test public void testMultiRowVectorFlush() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream iStream = new OptimizedInterceptedFileOutputStream(stream); iStream.write(new AugmentedString(123456789)); iStream.write(new AugmentedString(',')); iStream.write(new AugmentedString(11111111.5)); iStream.write(new AugmentedString(',')); iStream.write(new AugmentedString("foo")); iStream.write(new AugmentedString('\n')); iStream.write(new AugmentedString(234567890, ',', 22222222.5, ',', "bar", "\n")); iStream.flush(); ByteBuffer buffer = ByteBuffer.wrap(stream.toByteArray()); assert(InterceptMetadata.read(buffer) != null); assertVector(buffer, 8, new Integer[] {123456789, 234567890}); assertVector(buffer, 16, new Double[] {11111111.5, 22222222.5}); assertVarCharVector(buffer, 6, new Integer[] {0, 3, 6}, new String[] {"foo", "bar"}); assert(!buffer.hasRemaining()); }
@Test public void testMixedReadLine() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.write(new AugmentedString(2, ',', 2.5, ',', "bar", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); AugmentedString line = inStream.readLine(); assert(line.getState()[0].equals(1)); assert(line.getState()[1].equals(1.5)); assert(line.getState()[2].toString().equals("foo")); byte[] bytes = new byte[6]; int read = inStream.read(bytes, 2, 6); assert(read == 6); assert(new String(bytes).equals("2.5,ba")); assert(inStream.readLine().equals("r\n")); }
@Test public void testReadLine() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.write(new AugmentedString(2, ',', 2.5, ',', "bar", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); AugmentedString line = inStream.readLine(); assert(line.getState()[0].equals(1)); assert(line.getState()[1].equals(1.5)); assert(line.getState()[2].toString().equals("foo")); line = inStream.readLine(); assert(line.getState()[0].equals(2)); assert(line.getState()[1].equals(2.5)); assert(line.getState()[2].toString().equals("bar")); assert(inStream.readLine() == null); }
public S3TransportBuffer(long maxBytes, boolean useCompression, S3TransportSerializer serializer) throws TransportException { this.maxBytes = maxBytes; this.serializer = serializer; baos = new ByteArrayOutputStream(); cos = new CountingOutputStream(baos); if (useCompression) { this.isCompressed = true; try { os = new BZip2CompressorOutputStream(cos); } catch (IOException e) { throw new TransportException("unable to create BZip2CompressorOutputStream", e); } } else { this.isCompressed = false; os = cos; } }
/** * <p>generate.</p> * * @return a {@link java.util.Set} object. * @throws java.io.IOException if any. */ public Set<String> generate() throws IOException { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); final PrintStream ps = new PrintStream(baos); codeModel.build(configuration.getOutputDirectory(), ps); ps.close(); final Set<String> generatedFiles = new HashSet<String>(); if (shouldGenerateResponseWrapper) { generatedFiles.add(generateResponseWrapper()); } generatedFiles.addAll(Arrays.asList(StringUtils.split(baos.toString()))); return generatedFiles; }
@Override public OutputStream openStream() throws IOException { synchronized (this) { ++countOpen; } return new ByteArrayOutputStream() { boolean closed = false; @SuppressWarnings("synthetic-access") @Override public void close() throws IOException { super.close(); processBytes(this.toByteArray()); synchronized (JsonStreamOutputHandler.this) { if (!closed) { --countOpen; closed = true; } if (countOpen == 0) { JsonStreamOutputHandler.this.notifyAll(); } } } }; }
public static WarpScriptStackFunction wrap(String name, InputStream in, boolean secure) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); byte[] buf = new byte[1024]; try { while(true) { int len = in.read(buf); if (len < 0) { break; } baos.write(buf, 0, len); } in.close(); String mc2 = new String(baos.toByteArray(), Charsets.UTF_8); return wrap(name, mc2, secure); } catch (IOException ioe) { throw new RuntimeException(ioe); } }
@SetEnvironment(executionEnvironments = {ExecutionEnvironment.ALL}) @Test(groups = "wso2.esb", description = "disabling auto primitive option with a given regex pattern in synapse " + "properties ") public void testDisablingAutoConversionToScientificNotationInJsonStreamFormatter() throws Exception { String payload = "<coordinates>\n" + " <location>\n" + " <name>Bermuda Triangle</name>\n" + " <n>25e1</n>\n" + " <w>7.1e1</w>\n" + " </location>\n" + " <location>\n" + " <name>Eiffel Tower</name>\n" + " <n>4.8e3</n>\n" + " <e>1.8e2</e>\n" + " </location>\n" + "</coordinates>"; HttpResponse response = httpClient.doPost(getProxyServiceURLHttp("JSONDisableAutoPrimitiveNumericTestProxy"), null, payload, "application/xml"); ByteArrayOutputStream bos = new ByteArrayOutputStream(); response.getEntity().writeTo(bos); String actualResult = new String(bos.toByteArray()); String expectedPayload = "{\"coordinates\":{\"location\":[{\"name\":\"Bermuda Triangle\",\"n\":\"25e1\"" + ",\"w\":\"7.1e1\"},{\"name\":\"Eiffel Tower\",\"n\":\"4.8e3\",\"e\":\"1.8e2\"}]}}"; Assert.assertEquals(actualResult, expectedPayload); }
@Test(groups = "wso2.esb", description = "cache meditor test enabling axis2 clustering.") public void testDistributedCachingHeaderSerialization() throws Exception { String requestXml = "<a>ABC</a>"; SimpleHttpClient httpClient = new SimpleHttpClient(); Map<String, String> headers = new HashMap<String, String>(); headers.put("Content-Type", "application/xml;charset=UTF-8"); HttpResponse response1 = httpClient.doPost(getApiInvocationURL("CachingTest")+"/test", headers, requestXml, "application/xml;charset=UTF-8"); ByteArrayOutputStream baos1 = new ByteArrayOutputStream(); response1.getEntity().writeTo(baos1); String actualValue1 = baos1.toString(); // this is to populate response from cache mediator HttpResponse response2 = httpClient.doPost(getApiInvocationURL("CachingTest")+"/test", headers, requestXml, "application/xml;charset=UTF-8"); ByteArrayOutputStream baos2 = new ByteArrayOutputStream(); response2.getEntity().writeTo(baos2); String actualValue2 = baos2.toString(); Assert.assertEquals(actualValue1, requestXml); Assert.assertEquals(actualValue2, requestXml); Assert.assertTrue(stringExistsInLog("CACHEMATCHEDCACHEMATCHED")); }
@Test public void testVectorFlush() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream iStream = new OptimizedInterceptedFileOutputStream(stream); OptimizedInterceptedOutputStreamWriter writer = new OptimizedInterceptedOutputStreamWriter(iStream); writer.write(new AugmentedString(1)); writer.write(new AugmentedString(',')); writer.write(new AugmentedString(1.5)); writer.write(new AugmentedString(',')); writer.write(new AugmentedString("foo")); writer.write(new AugmentedString('\n')); writer.flush(); ByteBuffer buffer = ByteBuffer.wrap(stream.toByteArray()); assert(InterceptMetadata.read(buffer) != null); assertVector(buffer, 4, new Integer[] {1}); assertVector(buffer, 8, new Double[] {1.5}); assertVarCharVector(buffer, 3, new Integer[] {0, 3}, new String[] {"foo"}); assert(!buffer.hasRemaining()); }
@SetEnvironment(executionEnvironments = {ExecutionEnvironment.ALL}) @Test(groups = "wso2.esb", description = "disabling auto primitive option in synapse properties ", enabled = false) public void testDisablingAutoConversionToScientificNotationInJsonStreamFormatter() throws Exception { String payload = "{\"state\":[{\"path\":\"user_programs_progress\",\"entry\":" + "[{\"value\":\"false\",\"key\":\"testJson14\"}]}]}"; HttpResponse response = httpClient.doPost("http://localhost:8280/ESBJAVA4572abc/dd", null, payload, "application/json"); ByteArrayOutputStream bos = new ByteArrayOutputStream(); response.getEntity().writeTo(bos); String exPayload = new String(bos.toByteArray()); String val = "{\"state\":[{\"path\":\"user_programs_progress\",\"entry\":" + "[{\"value\":\"false\",\"key\":\"testJson14\"}]}]}"; Assert.assertEquals(val, exPayload); }
@Test public void testReadBytes() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.write(new AugmentedString(2, ',', 2.5, ',', "bar", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); byte[] bytes = new byte[20]; assert(inStream.read(bytes) == 20); assert(new String(bytes).equals("1,1.5,foo\n2,2.5,bar\n")); assert(inStream.read() == -1); }
@Test public void testReadMoreBytes() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.write(new AugmentedString(2, ',', 2.5, ',', "bar", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); byte[] bytes = new byte[30]; assert(inStream.read(bytes) == 20); assert(new String(bytes, 0, 20).equals("1,1.5,foo\n2,2.5,bar\n")); assert(inStream.read() == -1); }
@Test public void testReadFewerBytes() throws Exception { ByteArrayOutputStream stream = new ByteArrayOutputStream(1024); OptimizedInterceptedFileOutputStream outStream = new OptimizedInterceptedFileOutputStream(stream); outStream.write(new AugmentedString(1, ',', 1.5, ',', "foo", '\n')); outStream.write(new AugmentedString(2, ',', 2.5, ',', "bar", '\n')); outStream.close(); OptimizedInterceptedFileInputStream inStream = new OptimizedInterceptedFileInputStream(new ByteArrayInputStream(stream.toByteArray())); byte[] bytes = new byte[10]; assert(inStream.read(bytes) == 10); assert(new String(bytes).equals("1,1.5,foo\n")); byte[] bytes2 = new byte[9]; assert(inStream.read(bytes2) == 9); assert(new String(bytes2).equals("2,2.5,bar")); assert(inStream.read() != -1); assert(inStream.read() == -1); }
@Override public void init(RunConfig config) throws InvalidTestFormatException { super.init(config); outBuffer = new ByteArrayOutputStream(); File file = new File(GR.getGoldenDir(), goldenFileName); try { data = MTTestResourceManager.goldenFileToByteArray(file.getPath()); dataBuffer = new ByteArrayInputStream(data); compressZip(dataBuffer, outBuffer); compressedBuffer = new ByteArrayInputStream(outBuffer.toByteArray()); } catch (IOException e) { throw new GoldenFileNotFoundException(file, this.getClass()); } }
@Test public void testSerDe() { TinyMetric metric = createMetric(); for (int i = 1; i <= 10; i++) { metric.append(i); } Kryo kryo = new Kryo(); ByteArrayOutputStream bao = new ByteArrayOutputStream(); Output output = new Output(bao); kryo.writeObject(output, metric); output.close(); TinyMetric deser = kryo.readObject(new Input(new ByteArrayInputStream(bao.toByteArray())), TinyMetric.class); assertEquals(metric.size(), deser.size()); assertEquals(metric.getNumRecords(), deser.getNumRecords()); for (int i = 0; i < metric.getNumRecords(); i++) { assertEquals(metric.get(i), deser.get(i)); } }
/** * 创建文件 * @param response * @param workbook * @param fileName * @return boolean * @throws Exception */ public static FileTransfer createExcel(HttpServletResponse response, HSSFWorkbook workbook, String fileName) throws Exception { boolean flag = false; try { response.reset(); response.setHeader("Content-Disposition", "attachment;filename=" + new String(fileName.getBytes(), "iso8859-1")); //ServletOutputStream out = response.getOutputStream(); ByteArrayOutputStream buffer = new ByteArrayOutputStream(); workbook.write(buffer); return new FileTransfer(fileName, "application/vnd.ms-excel", buffer.toByteArray()); // 弹出下载对话框 //out.flush(); //out.close(); //flag = true; } catch (Exception e) { logger.error(fileName + " :文件创建失败"); throw e; } //return flag; }
/** * 结算制表下载 * @param batch 结算批次号 * @return * @throws Exception */ public FileTransfer downloadSettleTB(String batch) throws Exception { String fileName = batch + "settleTB.xls"; File settlementFile = new File(Ryt.getParameter("SettlementFilePath") + fileName); if (settlementFile.exists()) { BufferedInputStream bis = null; try { InputStream is = new FileInputStream(settlementFile); ByteArrayOutputStream buffer = new ByteArrayOutputStream(); buffer.write(is); return new FileTransfer(fileName, "application/x-xls", buffer.toByteArray()); } catch (IOException e) { throw e; } finally { if (bis != null) bis.close(); } } else { return null; } }
@Test public void withShortData__writeTo__shouldWriteData() throws Exception { writeShortTestData(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); deferredFileBody.writeTo(baos); assertArrayEquals(TEST_DATA_SHORT, baos.toByteArray()); }
public Pair<ProcessingLifecycleStatus, byte[]> getCurrentScreen(final ProcessingLifecycleStatus status, final AssumedScreenTest screenTest) throws ApplicationDownException, IOException { if(!processManager.isMtgoRunningOrLoading()) { throw new ApplicationDownException("MTGO is not running!"); } BufferedImage bi = robot.createScreenCapture(new Rectangle(0, 0, screenWidth, screenHeight)); if(bi != null) { RawLines rawLines; if (screenTest == AssumedScreenTest.NOT_NEEDED) { rawLines = tesseractWrapper.getRawText(bi); } else { rawLines = tesseractWrapper.getRawText(bi, screenTest.getScreenTestBounds()); } logger.info("Processing raw lines"); final ProcessingLifecycleStatus outcomeStatus = rawLinesProcessor.determineLifecycleStatus(rawLines); logger.info("Determined new status: " + status.name()); ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageIO.write(bi, "jpg", baos); baos.flush(); byte[] imageAsByteArray = baos.toByteArray(); baos.close(); return new ImmutablePair<>(outcomeStatus, imageAsByteArray); } throw new ApplicationDownException("Somehow made it to this unreachable point"); }
private BotCamera createBotCamera(BufferedImage image, PlayerBot remotePlayerBot) throws IOException { ByteArrayOutputStream baos = new ByteArrayOutputStream(); ImageIO.write(image, "jpg", baos ); baos.flush(); byte[] imageInByte = baos.toByteArray(); BotCamera botCamera = new BotCamera(imageInByte, new Date()); botCamera.setPlayerBot(remotePlayerBot); return botCamera; }