下面列出了怎么用java.io.ByteArrayOutputStream的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
public void invokeHandler_invalidModelTypes_causesSchemaValidationFailure() throws IOException {
// use actual validator to verify behaviour
final WrapperOverride wrapper = new WrapperOverride(providerLoggingCredentialsProvider, platformEventsLogger,
providerEventsLogger, providerMetricsPublisher, new Validator() {
}, httpClient);
wrapper.setTransformResponse(resourceHandlerRequest);
try (final InputStream in = loadRequestStream("create.request.with-invalid-model-types.json");
final OutputStream out = new ByteArrayOutputStream()) {
final Context context = getLambdaContext();
wrapper.handleRequest(in, out, context);
// verify output response
verifyHandlerResponse(out,
ProgressEvent.<TestModel, TestContext>builder().errorCode(HandlerErrorCode.InvalidRequest)
.status(OperationStatus.FAILED)
.message("Model validation failed (#/property1: expected type: String, found: JSONArray)").build());
}
}
@Test
public void T_dataSizeAfterAppend_equalsDataBinarySize_withNestedSimpleCaseChild() throws IOException {
PushdownSupportedBlockWriter writer = new PushdownSupportedBlockWriter();
writer.setup( 1024 * 1024 * 8 , new Configuration() );
List<ColumnBinary> childList = createSimpleCaseData();
List<ColumnBinary> list = Arrays.asList( DumpSpreadColumnBinaryMaker.createSpreadColumnBinary(
"parent" , 10 , childList ) );
int sizeAfterAppend = writer.sizeAfterAppend( list );
writer.append( 10 , list );
int outputDataSize = writer.size();
ByteArrayOutputStream out = new ByteArrayOutputStream();
writer.writeVariableBlock( out );
byte[] block = out.toByteArray();
assertEquals( outputDataSize , block.length );
}
/**
* Write the given properties list to a byte array and return it. Properties with
* a key or value that is not a String is filtered out. The stream written to the byte
* array is ISO 8859-1 encoded.
*/
private static byte[] serializePropertiesToByteArray(Properties p) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
Properties props = new Properties();
// stringPropertyNames() returns a snapshot of the property keys
Set<String> keyset = p.stringPropertyNames();
for (String key : keyset) {
String value = p.getProperty(key);
props.put(key, value);
}
props.store(out, null);
return out.toByteArray();
}
public void setInputStreamFrom(InputStream in) throws IOException {
assert(bytes == null);
assert(assertReadyToReadFrom(this, in));
setPhase(READ_PHASE);
this.in = in;
if (optDumpBands) {
// Tap the stream.
bytesForDump = new ByteArrayOutputStream();
this.in = new FilterInputStream(in) {
@Override
public int read() throws IOException {
int ch = in.read();
if (ch >= 0) bytesForDump.write(ch);
return ch;
}
@Override
public int read(byte b[], int off, int len) throws IOException {
int nr = in.read(b, off, len);
if (nr >= 0) bytesForDump.write(b, off, nr);
return nr;
}
};
}
super.readyToDisburse();
}
private static Bitmap compressBitmap(Bitmap bitmap, long sizeLimit) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int quality = 90;
bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
LogUtil.i(TAG, "origin size:" + baos.size());
//TODO has problem
while (baos.size() / 1024 > sizeLimit) {
LogUtil.i(TAG, "after size:" + baos.size());
// 清空baos
baos.reset();
quality -= 10;
bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos);
}
return BitmapFactory.decodeStream(new ByteArrayInputStream(baos.toByteArray()), null, null);
}
static void serial(URI u) throws IOException, URISyntaxException {
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(u);
oo.close();
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
try {
Object o = oi.readObject();
eq(u, (URI)o);
} catch (ClassNotFoundException x) {
x.printStackTrace();
throw new RuntimeException(x.toString());
}
testCount++;
}
@Test
public void copyByTestReturnCheckError()
throws InstantiationException
{
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
PrintStream printStream = AopFactory.proxy(PrintStream.class)
.byInstance(UnsafeHelper.allocateInstance(PrintStream.class))
.whereMethod(methodInfo -> methodInfo.getName().equals("checkError"))
.around(proxyContext -> true);
try (ByteArrayInputStream inputStream = new ByteArrayInputStream("IOUtilsTest".getBytes(UTF_8))) {
IOUtils.copyBytes(inputStream, printStream, 1024, false);
Assert.assertEquals("IOUtilsTest", outputStream.toString(UTF_8.name()));
Assert.fail();
}
catch (IOException e) {
Assert.assertEquals(e.getMessage(), "Unable to write to output stream.");
}
}
private byte[] gzipMessage(byte[] message) {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
GZIPOutputStream stream = new GZIPOutputStream(bos);
stream.write(message);
stream.finish();
Closer.close(stream);
byte[] zipped = bos.toByteArray();
Closer.close(bos);
return zipped;
} catch (IOException e) {
return null;
}
}
private static void testWrapEncode2(final Base64.Encoder encoder)
throws IOException {
System.err.println("\nEncoder.wrap test II ");
final byte[] secondTestBuffer =
"api/java_util/Base64/index.html#GetEncoderMimeCustom[noLineSeparatorInEncodedString]"
.getBytes(US_ASCII);
String base64EncodedString;
ByteArrayOutputStream secondEncodingStream = new ByteArrayOutputStream();
OutputStream base64EncodingStream = encoder.wrap(secondEncodingStream);
base64EncodingStream.write(secondTestBuffer);
base64EncodingStream.close();
final byte[] encodedByteArray = secondEncodingStream.toByteArray();
System.err.print("result = " + new String(encodedByteArray, US_ASCII)
+ " after wrap Base64 encoding of string");
base64EncodedString = new String(encodedByteArray, US_ASCII);
if (base64EncodedString.contains("$$$")) {
throw new RuntimeException(
"Base64 encoding contains line separator after wrap 2 invoked ... \n");
}
}
@Override
public byte[] generatorCode(String[] tableNames) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zip = new ZipOutputStream(outputStream);
for(String tableName : tableNames){
//查询表信息
Map<String, String> table = queryTable(tableName);
//查询列信息
List<Map<String, String>> columns = queryColumns(tableName);
//生成代码
GenUtils.generatorCode(table, columns, zip);
}
IOUtils.closeQuietly(zip);
return outputStream.toByteArray();
}
/**
* Decompress a byte array which was compressed using Deflate.
* @param bytearray non-null byte array to be decompressed
* @return the decompressed payload or an empty array in case of bytearray is null
* @throws DataFormatException in case the payload cannot be decompressed
*/
public static byte[] decompressUsingInflate(byte[] bytearray) throws DataFormatException {
if (bytearray == null) return new byte[0];
try (final ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
final Inflater inflater = new Inflater();
final byte[] buff = new byte[1024];
inflater.setInput(bytearray);
while (!inflater.finished()) {
int count = inflater.inflate(buff);
bos.write(buff, 0, count);
}
inflater.end();
bos.flush();
return bos.toByteArray();
} catch (IOException e) {
throw new DataFormatException(e.getMessage());
}
}
DistributedKeySignature(String signatureAlgorithm) throws NoSuchAlgorithmException {
LOG.debug("constructor: " + signatureAlgorithm);
this.signatureAlgorithm = signatureAlgorithm;
if (!digestAlgos.containsKey(signatureAlgorithm)) {
LOG.error("no such algo: " + signatureAlgorithm);
throw new NoSuchAlgorithmException(signatureAlgorithm);
} else {
String digestAlgo = (String)digestAlgos.get(signatureAlgorithm);
if (null != digestAlgo) {
this.messageDigest = MessageDigest.getInstance(digestAlgo);
this.precomputedDigestOutputStream = null;
} else {
LOG.debug("NONE message digest");
this.messageDigest = null;
this.precomputedDigestOutputStream = new ByteArrayOutputStream();
}
}
}
/**
* Produce a string that is a decomposition of the given x.509 or ASN1 encoded
* object. For learning and debugging purposes.
*/
public static String decomposeASN1Encoded(ByteString input)
throws Exception
{
ByteArrayOutputStream byte_out = new ByteArrayOutputStream();
PrintStream out = new PrintStream(byte_out);
ASN1StreamParser parser = new ASN1StreamParser(input.toByteArray());
out.println("ASN1StreamParser");
while(true)
{
ASN1Encodable encodable = parser.readObject();
if (encodable == null) break;
decomposeEncodable(encodable, 2, out);
}
out.flush();
return new String(byte_out.toByteArray());
}
/**
* 解压
* @param data
* @return
* @throws Exception
*/
public static byte[] ungzip(byte[] data) throws Exception {
ByteArrayInputStream bis = new ByteArrayInputStream(data);
GZIPInputStream gzip = new GZIPInputStream(bis);
byte[] buf = new byte[1024];
int num = -1;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((num = gzip.read(buf, 0, buf.length)) != -1) {
bos.write(buf, 0, num);
}
gzip.close();
bis.close();
byte[] ret = bos.toByteArray();
bos.flush();
bos.close();
return ret;
}
@Test
/**
* verify that umlaut like äö etc are not encoded in UTF-8 in attributes
*/
public void testSerializeUmlaut() throws IOException {
Element xml = Manager.parse(context,
TestingUtilities.loadTestResourceStream("validator", "cda", "example.xml"), FhirFormat.XML);
List<Element> title = xml.getChildrenByName("title");
assertTrue(title != null && title.size() == 1);
Element value = title.get(0).getChildren().get(0);
Assertions.assertEquals("Episode Note", value.getValue());
value.setValue("öé");
ByteArrayOutputStream baosXml = new ByteArrayOutputStream();
Manager.compose(TestingUtilities.context(), xml, baosXml, FhirFormat.XML, OutputStyle.PRETTY, null);
String cdaSerialised = baosXml.toString("UTF-8");
assertTrue(cdaSerialised.indexOf("öé") > 0);
}
/**
* Encodes a byte array into percent encoding
*
* @param source The byte-representation of the string.
* @param bitSet The BitSet for characters to skip encoding
* @return The percent-encoded byte array
*/
public static byte[] encode(byte[] source, BitSet bitSet) {
ByteArrayOutputStream bos = new ByteArrayOutputStream(source.length * 2);
for (int i = 0; i < source.length; i++) {
int b = source[i];
if (b < 0) {
b += 256;
}
if (bitSet.get(b)) {
bos.write(b);
} else {
bos.write('%');
char hex1 = Character.toUpperCase(Character.forDigit((b >> 4) & 0xF, 16));
char hex2 = Character.toUpperCase(Character.forDigit(b & 0xF, 16));
bos.write(hex1);
bos.write(hex2);
}
}
return bos.toByteArray();
}
/**
* Reads a byte array
*
* <pre>
* B b16 b8 data value
* </pre>
*/
public byte[] readBytes()
throws IOException
{
int tag = is.read();
if (tag == 'N')
return null;
if (tag != 'B')
throw expect("bytes", tag);
int b16 = is.read();
int b8 = is.read();
int len = (b16 << 8) + b8;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
for (int i = 0; i < len; i++)
bos.write(is.read());
return bos.toByteArray();
}
public static byte[] content(URI uri, ProgressMonitor<Long> monitor) throws IOException {
try (CloseableHttpResponse rsp = get(uri)) {
if (rsp.getStatusLine().getStatusCode() != 200) {
throw new IOException("http request failed: " + rsp.getStatusLine().getStatusCode());
}
HttpEntity entity = rsp.getEntity();
long length = entity.getContentLength();
int clength = (int)length;
if (clength <= 0 || length >= Integer.MAX_VALUE) clength = 256;
try (InputStream is = entity.getContent();
ByteArrayOutputStream os = new ByteArrayOutputStream(clength)) {
copy(is, os, length, monitor);
EntityUtils.consume(entity);
return os.toByteArray();
}
}
}
public static String encodeToString(BufferedImage image, String type) {
String imageString = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
ImageIO.write(image, type, bos);
byte[] imageBytes = bos.toByteArray();
imageString = new String(Base64.encodeBase64(imageBytes));
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
return imageString;
}
@Test
public void marshal() {
CrossDomainConfig config = new CrossDomainConfig();
config.setAllowedMethods(Arrays.asList("GET", "OPTIONS"));
config.setAllowedOrigins(Arrays.asList("a", "b"));
config.setAllowedHeaders(Arrays.asList("A", "B"));
config.setAllowCredentials(Boolean.TRUE);
ByteArrayOutputStream out = new ByteArrayOutputStream();
JaxbUtil.marshal(config, out);
JsonObject result = Json.createReader(new ByteArrayInputStream(out.toByteArray())).readObject();
assertThat(result.getJsonArray("allowedMethods").getValuesAs(JsonString.class)).containsExactlyInAnyOrder(Json.createValue("GET"), Json.createValue("OPTIONS"));
assertThat(result.getJsonArray("allowedOrigins").getValuesAs(JsonString.class)).containsExactlyInAnyOrder(Json.createValue("a"), Json.createValue("b"));
assertThat(result.getJsonArray("allowedHeaders").getValuesAs(JsonString.class)).containsExactlyInAnyOrder(Json.createValue("A"), Json.createValue("B"));
assertThat(result.get("allowCredentials")).isEqualTo(JsonValue.TRUE);
}
private static MyClassLoader createClassLoaderWithEventClass() throws Exception {
String resourceName = EVENT_NAME.replace('.', '/') + ".class";
try (InputStream is = TestUnloadEventClassCount.class.getClassLoader().getResourceAsStream(resourceName)) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int byteValue = 0;
while ((byteValue = is.read(buffer, 0, buffer.length)) != -1) {
baos.write(buffer, 0, byteValue);
}
baos.flush();
MyClassLoader myClassLoader = new MyClassLoader();
Class<?> eventClass = myClassLoader.defineClass(EVENT_NAME, baos.toByteArray());
if (eventClass == null) {
throw new Exception("Could not define test class");
}
if (eventClass.getSuperclass() != Event.class) {
throw new Exception("Superclass should be jdk.jfr.Event");
}
if (eventClass.getSuperclass().getClassLoader() != null) {
throw new Exception("Class loader of jdk.jfr.Event should be null");
}
if (eventClass.getClassLoader() != myClassLoader) {
throw new Exception("Incorrect class loader for event class");
}
eventClass.newInstance(); // force <clinit>
return myClassLoader;
}
}
/**
* event handler method to handle the FlowFile being forwarded to the Processor by the framework. The FlowFile contents is sent out over a TCP connection using an acquired ChannelSender object. If
* the FlowFile contents was sent out successfully then the FlowFile is forwarded to the success relationship. If an error occurred then the FlowFile is forwarded to the failure relationship.
*
* @param context
* - the current process context.
*
* @param sessionFactory
* - a factory object to obtain a process session.
*/
@Override
public void onTrigger(final ProcessContext context, final ProcessSessionFactory sessionFactory) throws ProcessException {
final ProcessSession session = sessionFactory.createSession();
final FlowFile flowFile = session.get();
if (flowFile == null) {
pruneIdleSenders(context.getProperty(IDLE_EXPIRATION).asTimePeriod(TimeUnit.MILLISECONDS).longValue());
context.yield();
return;
}
ChannelSender sender = acquireSender(context, session, flowFile);
if (sender == null) {
return;
}
try {
String outgoingMessageDelimiter = getOutgoingMessageDelimiter(context, flowFile);
ByteArrayOutputStream content = readContent(session, flowFile);
if (outgoingMessageDelimiter != null) {
Charset charset = Charset.forName(context.getProperty(CHARSET).getValue());
content = appendDelimiter(content, outgoingMessageDelimiter, charset);
}
StopWatch stopWatch = new StopWatch(true);
sender.send(content.toByteArray());
session.getProvenanceReporter().send(flowFile, transitUri, stopWatch.getElapsed(TimeUnit.MILLISECONDS));
session.transfer(flowFile, REL_SUCCESS);
session.commit();
} catch (Exception e) {
onFailure(context, session, flowFile);
getLogger().error("Exception while handling a process session, transferring {} to failure.", new Object[] { flowFile }, e);
} finally {
// If we are going to use this sender again, then relinquish it back to the pool.
if (!isConnectionPerFlowFile(context)) {
relinquishSender(sender);
} else {
sender.close();
}
}
}
@Override
protected void _decrypt(byte[] data, ByteArrayOutputStream stream) {
int noBytesProcessed;
byte[] buffer = new byte[data.length];
noBytesProcessed = decCipher.processBytes(data, 0, data.length, buffer, 0);
stream.write(buffer, 0, noBytesProcessed);
}
void convertToNodes() throws CanonicalizationException,
ParserConfigurationException, IOException, SAXException {
if (dfactory == null) {
dfactory = DocumentBuilderFactory.newInstance();
dfactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
dfactory.setValidating(false);
dfactory.setNamespaceAware(true);
}
DocumentBuilder db = dfactory.newDocumentBuilder();
// select all nodes, also the comments.
try {
db.setErrorHandler(new com.sun.org.apache.xml.internal.security.utils.IgnoreAllErrorHandler());
Document doc = db.parse(this.getOctetStream());
this.subNode = doc;
} catch (SAXException ex) {
// if a not-wellformed nodeset exists, put a container around it...
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write("<container>".getBytes("UTF-8"));
baos.write(this.getBytes());
baos.write("</container>".getBytes("UTF-8"));
byte result[] = baos.toByteArray();
Document document = db.parse(new ByteArrayInputStream(result));
this.subNode = document.getDocumentElement().getFirstChild().getFirstChild();
} finally {
if (this.inputOctetStreamProxy != null) {
this.inputOctetStreamProxy.close();
}
this.inputOctetStreamProxy = null;
this.bytes = null;
}
}
@Override
protected void compile() throws IOException {
final ByteArrayOutputStream out = new ByteArrayOutputStream();
final ByteArrayOutputStream err = new ByteArrayOutputStream();
final List<String> args = getCompilerArgs();
int errors;
try {
errors = evaluateScript(out, err, args.toArray(new String[args.size()]));
} catch (final AssertionError e) {
final PrintWriter writer = new PrintWriter(err);
e.printStackTrace(writer);
writer.flush();
errors = 1;
}
if (errors != 0 || checkCompilerMsg) {
result.err = err.toString();
if (expectCompileFailure || checkCompilerMsg) {
final PrintStream outputDest = new PrintStream(new FileOutputStream(getErrorFileName()));
TestHelper.dumpFile(outputDest, new StringReader(new String(err.toByteArray())));
outputDest.println("--");
}
if (errors != 0 && !expectCompileFailure) {
fail(String.format("%d errors compiling %s", errors, testFile));
}
if (checkCompilerMsg) {
compare(getErrorFileName(), expectedFileName, true);
}
}
if (expectCompileFailure && errors == 0) {
fail(String.format("No errors encountered compiling negative test %s", testFile));
}
}
public static String encodeBinaryData( byte[] val ) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream gzos = new GZIPOutputStream( baos );
BufferedOutputStream bos = new BufferedOutputStream( gzos );
bos.write( val );
bos.flush();
bos.close();
return new String( Base64.encodeBase64( baos.toByteArray() ) );
}
static byte[] inputStreamToByteArray(final InputStream is) throws IOException {
final ByteArrayOutputStream buf = new ByteArrayOutputStream();
final byte[] temp = new byte[1024];
int read;
while ((read = is.read(temp)) > 0) {
buf.write(temp, 0, read);
}
is.close();
return buf.toByteArray();
}
@Override
public ExecutionResult executeScript(String source, RequestContainer request, ResponseContainer response, RequestExecutionContext context) {
ByteArrayOutputStream logStream = new ByteArrayOutputStream();
initGlobalBindings();
Bindings bindings = engine.createBindings();
engine.setContext(new SimpleScriptContext());
//we need to use globalBindings as engnine bindings and the normal bindings as globalBindings, otherwise things like chai dont work
//bc they modify object prototype and this change is not resolved if in global scope
engine.getContext().setBindings(bindings, ScriptContext.GLOBAL_SCOPE);
engine.getContext().setBindings(globalBindings, ScriptContext.ENGINE_SCOPE);
engine.getContext().setErrorWriter(new OutputStreamWriter(logStream));
engine.getContext().setWriter(new OutputStreamWriter(logStream));
var facade = new MilkmanNashornFacade(request, response, context, toaster);
bindings.put("milkman", facade);
bindings.put("mm", facade);
try {
Object eval = engine.eval(source);
return new ExecutionResult(logStream.toString(), Optional.ofNullable(eval));
} catch (Exception e) {
String causeMessage = ExceptionUtils.getRootCauseMessage(e);
toaster.showToast("Failed to execute script: " + causeMessage);
log.error("failed to execute script", e);
}
return new ExecutionResult(logStream.toString(), Optional.empty());
}
static void setUp() throws Exception {
testarray = new float[1024];
for (int i = 0; i < 1024; i++) {
double ii = i / 1024.0;
ii = ii * ii;
testarray[i] = (float)Math.sin(10*ii*2*Math.PI);
testarray[i] += (float)Math.sin(1.731 + 2*ii*2*Math.PI);
testarray[i] += (float)Math.sin(0.231 + 6.3*ii*2*Math.PI);
testarray[i] *= 0.3;
}
test_byte_array = new byte[testarray.length*2];
AudioFloatConverter.getConverter(format).toByteArray(testarray, test_byte_array);
buffer = new ModelByteBuffer(test_byte_array);
byte[] test_byte_array2 = new byte[testarray.length*3];
buffer24 = new ModelByteBuffer(test_byte_array2);
test_byte_array_8ext = new byte[testarray.length];
byte[] test_byte_array_8_16 = new byte[testarray.length*2];
AudioFloatConverter.getConverter(format24).toByteArray(testarray, test_byte_array2);
int ix = 0;
int x = 0;
for (int i = 0; i < test_byte_array_8ext.length; i++) {
test_byte_array_8ext[i] = test_byte_array2[ix++];
test_byte_array_8_16[x++] = test_byte_array2[ix++];
test_byte_array_8_16[x++] = test_byte_array2[ix++];
}
buffer16_8 = new ModelByteBuffer(test_byte_array_8_16);
buffer8 = new ModelByteBuffer(test_byte_array_8ext);
AudioInputStream ais = new AudioInputStream(buffer.getInputStream(), format, testarray.length);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
AudioSystem.write(ais, AudioFileFormat.Type.WAVE, baos);
buffer_wave = new ModelByteBuffer(baos.toByteArray());
}
public static Character encodeDecode(Character character) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
XMLEncoder encoder = new XMLEncoder(out);
encoder.writeObject(character);
encoder.close();
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
return (Character)new XMLDecoder(in).readObject();
}